package com.sg.service.biz.app.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.*;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerDetailComReqDto;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerListComReqDto;
import com.sg.service.biz.app.*;
import com.sg.common.exception.Assert;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.dal.po.mbg.*;
import com.wicket.okrcomponent.integration.*;
import com.wicket.okrcomponent.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class CustomExecutionCycleServiceImpl
        implements com.wicket.okrapp.biz.service.CustomExecutionCycleService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
    @Resource
    private NbCustomExecutionCycle nbCustomExecutionCycle;
    @Resource
    private DivineDataService fwCompDivineDataClient;
    @Resource
    private SchemeOpenRecordService fwCompSchemeOpenRecordClient;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private MOmsCycleService mOmsCycleService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private MOmsTargetCyclePlanSetService mOmsTargetCyclePlanSetService;
    @Resource
    private TargetContentService targetContentService;
    @Resource
    private FwCompBusinessAtomClient fwCompBusinessAtomClient;
    @Resource
    private TargetCycleService targetCycleService;
    @Resource
    private OffStateService offStateService;
    @Resource
    private MOmsEvaCycleConfService mOmsEvaCycleConfService;
    @Resource
    private CycleConfService cycleConfService;
    @Resource
    private MOmsCycleTimeRuleService mOmsCycleTimeRuleService;
    @Resource
    private IndexSystemService indexSystemService;
    @Resource
    private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
    @Resource
    private CycleTypeService cycleTypeService;
    @Resource
    private TaskGenService taskGenService;
    @Resource
    private MOmsExecuteProgressService mOmsExecuteProgressService;
    @Resource
    private ExecuteProgressService executeProgressService;
    @Resource
    private TemplateEngineService fwCompTemplateEngineClient;
    @Resource
    private MOmsTaskService mOmsTaskService;
    @Resource
    private ExecuteCycleService executeCycleService;
    @Resource
    private MOmsTargetService mOmsTargetService;
    @Resource
    private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
    @Resource
    private TargetCalcService targetCalcService;
    @Resource
    private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
    @Resource
    private TargetContComService targetContComService;
    @Resource
    private EvaThemeService evaThemeService;
    @Resource
    private BusinessAtomService businessAtomService;
//@Resource
    //private MCustomFields5Service mCustomFields5Service;
//@Resource
    //private undefinedService undefinedService;
//@Resource
    //private MCustomFields3Service mCustomFields3Service;
//@Resource
    //private MOmsConfSchemeOptionResultService mOmsConfSchemeOptionResultService;

    /**
     * D3删除目标内容执行周期(公共)[6648]
     * gen by moon at 5/13/2023, 9:32:15 PM
     */
    @Trace(operationName = "D3删除目标内容执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteTargetContenteExecutionCycleComRespDto deleteTargetContenteExecutionCycleCom(DeleteTargetContenteExecutionCycleComReqDto reqDto) {


        //步骤0: M3执行接收字段入参（特殊方法） - implementAcceptField
        //ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
        ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:936436_1
        }

        /*M3执行接收字段入参（特殊方法）[6100]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(), "D3删除目标内容执行周期(公共)-M3执行接收字段入参（特殊方法）-被评对象目标周期ID不能为空", false);
        receptionServiceRes = nbCustomExecutionCycle.implementAcceptField(receptionServiceReq);


//步骤1: 3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于） - queryExecuteCycleStageList
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
        QueryExecuteCycleStageListReq queryExecuteCycleStageListReq = new QueryExecuteCycleStageListReq();
        queryExecuteCycleStageListReq.setIsDefinedExecuteCycleStage("TRUE");//sourceId:936365_1
        queryExecuteCycleStageListReq.setSubjectLifeCycle("EDITING");//sourceId:936442_1
        if (reqDto != null) {
            queryExecuteCycleStageListReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:936364_1
        }

        /*3-3-07查询执行周期阶段列表[3201]   */
        Assert.isNull(queryExecuteCycleStageListReq.getEvaObjTargetCycleId(), "D3删除目标内容执行周期(公共)-3-3-07查询执行周期阶段列表-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageListReq.getIsDefinedExecuteCycleStage(), "D3删除目标内容执行周期(公共)-3-3-07查询执行周期阶段列表-是否自定义执行周期阶段不能为空", false);
        Assert.isNull(queryExecuteCycleStageListReq.getSubjectLifeCycle(), "D3删除目标内容执行周期(公共)-3-3-07查询执行周期阶段列表-主体生命周期不能为空", false);
        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageList(queryExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤2: 3-3-07批量删执行周期阶段 - batchDeleteExecuteCycleStage
        boolean bOOLEAN;
        if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
            List<String> listString = new ArrayList<>();
            if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                listString = listOmsExecuteCycleStage.stream().map(item -> item.getExecuteCycleStageId())
                        .collect(Collectors.toList());/*list-to-strings*///sourceId:936368_1
            }

            /*3-3-07批量删执行周期阶段[2743]   */

            bOOLEAN = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;


        }

        DeleteTargetContenteExecutionCycleComRespDto retData = new DeleteTargetContenteExecutionCycleComRespDto();


        return retData;
    }

    /**
     * D3-执行根据自定义分析父周期(公共)[6654]
     * gen by moon at 5/14/2023, 5:03:32 PM
     */
    @Trace(operationName = "D3-执行根据自定义分析父周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementExecuteFatherCycleAnalysisByCustomizeComRespDto implementExecuteFatherCycleAnalysisByCustomizeCom(ImplementExecuteFatherCycleAnalysisByCustomizeComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 = null;
//virtualUsage 约定：是  41607
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq.setTureOrFalse("TRUE");//sourceId:938508_1_41607

        /*约定：是[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getTureOrFalse(), "D3-执行根据自定义分析父周期(公共)-约定：是-是否不能为空", false);
        receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


//virtualUsage 约定：否  41608
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:938509_1_41608

        /*约定：否[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_1.getTureOrFalse(), "D3-执行根据自定义分析父周期(公共)-约定：否-是否不能为空", false);
        receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


//virtualUsage D2检查时间范围查询(公共)  41602
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
        CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
        if (reqDto != null) {
            checkTimeScopeSearchComReqDto.setCurrentTime(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:937901_1_41602
            checkTimeScopeSearchComReqDto.setCompareTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:937903_1_41602
        }

        /*D2检查时间范围查询(公共)[3297]   */
        Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3-执行根据自定义分析父周期(公共)-D2检查时间范围查询(公共)-当前时间不能为空", false);
        Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3-执行根据自定义分析父周期(公共)-D2检查时间范围查询(公共)-比较时间不能为空", false);
        checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))) {
            //if(D2父周期开始时间分析.时间比较结果 等于 当前（等于）)  41603

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_2.setFatherCycleStartTimeIsModify(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:938519_1_41606
            }

            /*约定出参：父周期开始时间是否定制[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getFatherCycleStartTimeIsModify(), "D3-执行根据自定义分析父周期(公共)-约定出参：父周期开始时间是否定制-父周期开始时间是否定制不能为空", false);
            receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


            receptionServiceRes_5 = receptionServiceRes_4;
        } else if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))) {
            //elseif(D2父周期开始时间分析.时间比较结果 等于 之后（大于）)  41604

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_3.setFatherCycleStartTimeIsModify(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:938519_1_41605
            }

            /*约定出参：父周期开始时间是否定制[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getFatherCycleStartTimeIsModify(), "D3-执行根据自定义分析父周期(公共)-约定出参：父周期开始时间是否定制-父周期开始时间是否定制不能为空", false);
            receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


            receptionServiceRes_5 = receptionServiceRes_6;
        }
//virtualUsage D2检查时间范围查询(公共)  41609
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
        CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1 = new CheckTimeScopeSearchComReqDto();
        if (reqDto != null) {
            checkTimeScopeSearchComReqDto_1.setCurrentTime(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:937901_1_41609
            checkTimeScopeSearchComReqDto_1.setCompareTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:937903_1_41609
        }

        /*D2检查时间范围查询(公共)[3297]   */
        Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(), "D3-执行根据自定义分析父周期(公共)-D2检查时间范围查询(公共)-当前时间不能为空", false);
        Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(), "D3-执行根据自定义分析父周期(公共)-D2检查时间范围查询(公共)-比较时间不能为空", false);
        checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT"))) {
            //if(D2父周期结束时间分析.时间比较结果 等于 当前（等于）)  41610

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_4.setFatherCycleEndTimeIsModify(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:938521_1_41611
            }

            /*约定出参：父周期结束时间是否定制[6495]  用于特殊方法接收上游入参。 */

            receptionServiceRes_7 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_4);


            receptionServiceRes_8 = receptionServiceRes_7;
        } else if ((checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("BEFORE"))) {
            //elseif(D2父周期结束时间分析.时间比较结果 等于 之前（小于）)  41613

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_9 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_5 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_5.setFatherCycleEndTimeIsModify(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:938521_1_41614
            }

            /*约定出参：父周期结束时间是否定制[6495]  用于特殊方法接收上游入参。 */

            receptionServiceRes_9 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_5);


            receptionServiceRes_8 = receptionServiceRes_9;
        }
        ImplementExecuteFatherCycleAnalysisByCustomizeComRespDto retData = new ImplementExecuteFatherCycleAnalysisByCustomizeComRespDto();
        if (receptionServiceRes_5 != null) {
            retData.setFatherCycleStartTimeIsModify(receptionServiceRes_5.getFatherCycleStartTimeIsModify());//SimpleFieldAssign//sourceId:938544_1
        }
        if (receptionServiceRes_8 != null) {
            retData.setFatherCycleEndTimeIsModify(receptionServiceRes_8.getFatherCycleEndTimeIsModify());//SimpleFieldAssign//sourceId:938545_1
        }


        return retData;
    }

    /**
     * D3-执行回删过程执行周期(公共)[6658]
     * gen by moon at 5/14/2023, 3:01:47 AM
     */
    @Trace(operationName = "D3-执行回删过程执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDeletProgressCycleComRespDto implementDeletProgressCycleCom(ImplementDeletProgressCycleComReqDto reqDto) {


        //virtualUsage 3-3-07-查询执行周期列表（开始大于等于&结束小于）  41656
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
        QueryExecuteCycleGreaterAndEqualStartListReq queryExecuteCycleGreaterAndEqualStartListReq = new QueryExecuteCycleGreaterAndEqualStartListReq();
        queryExecuteCycleGreaterAndEqualStartListReq.setIsProcessCycleStage("TRUE");//sourceId:939166_1_41656
        queryExecuteCycleGreaterAndEqualStartListReq.setIsArchive("FALSE");//sourceId:939168_1_41656
        if (reqDto != null) {
            queryExecuteCycleGreaterAndEqualStartListReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939161_1_41656
            queryExecuteCycleGreaterAndEqualStartListReq.setCycleEndTime(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:939162_1_41656
            queryExecuteCycleGreaterAndEqualStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939288_1_41656
        }

        /*3-3-07-查询执行周期列表（开始大于等于&结束小于）[6660]   */
        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsProcessCycleStage(), "D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否过程周期阶段不能为空", false);
        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsArchive(), "D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否存档不能为空", false);
        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getEvaluationTemplateId(), "D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-评价模板ID不能为空", false);
        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleGreaterAndEqualStartList(queryExecuteCycleGreaterAndEqualStartListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsExecuteCycleStage != null && listOmsExecuteCycleStage != null && listOmsExecuteCycleStage.size() > 0)) {
            //if(3-3-07-查询定制开始时间与父周期开始时间范围.执行周期阶段列表数据集条数 大于 0)  41657

            boolean bOOLEAN;
            if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
                List<String> listString = new ArrayList<>();
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                    listString = listOmsExecuteCycleStage.stream().map(item -> item.getExecuteCycleStageId())
                            .collect(Collectors.toList());/*list-to-strings*///sourceId:938959_1_41658
                }

                /*3-3-07批量删执行周期阶段[2743]   */

//      bOOLEAN = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
//virtualUsage 3-3-07-查询执行周期列表（开始大于&结束小于等于）  41659
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 = new ArrayList<>();
        QueryExecuteCycleGreaterStartListReq queryExecuteCycleGreaterStartListReq = new QueryExecuteCycleGreaterStartListReq();
        queryExecuteCycleGreaterStartListReq.setIsProcessCycleStage("TRUE");//sourceId:939278_1_41659
        queryExecuteCycleGreaterStartListReq.setIsArchive("FALSE");//sourceId:939280_1_41659
        if (reqDto != null) {
            queryExecuteCycleGreaterStartListReq.setCycleStartTime(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:939276_1_41659
            queryExecuteCycleGreaterStartListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939277_1_41659
            queryExecuteCycleGreaterStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939279_1_41659
        }

        /*3-3-07-查询执行周期列表（开始大于&结束小于等于）[6661]   */
        Assert.isNull(queryExecuteCycleGreaterStartListReq.getIsProcessCycleStage(), "D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于&结束小于等于）-是否过程周期阶段不能为空", false);
        Assert.isNull(queryExecuteCycleGreaterStartListReq.getIsArchive(), "D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于&结束小于等于）-是否存档不能为空", false);
        Assert.isNull(queryExecuteCycleGreaterStartListReq.getEvaluationTemplateId(), "D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于&结束小于等于）-评价模板ID不能为空", false);
        listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleGreaterStartList(queryExecuteCycleGreaterStartListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsExecuteCycleStage_2 != null && listOmsExecuteCycleStage_2 != null && listOmsExecuteCycleStage_2.size() > 0)) {
            //if(3-3-07-查询定制结束时间与父周期结束时间范围.执行周期阶段列表数据集条数 大于 0)  41660

            boolean bOOLEAN_1;
            if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2.size() > 0) {
                List<String> listString_1 = new ArrayList<>();
                if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)) {
                    listString_1 = listOmsExecuteCycleStage_2.stream().map(item -> item.getExecuteCycleStageId())
                            .collect(Collectors.toList());/*list-to-strings*///sourceId:938959_1_41661
                }

                /*3-3-07批量删执行周期阶段[2743]   */

//      bOOLEAN_1 = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString_1)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
        ImplementDeletProgressCycleComRespDto retData = new ImplementDeletProgressCycleComRespDto();


        return retData;
    }

    /**
     * D3执行回写模板自定义执行周期起止时间定制答案(公共)[6659]
     * gen by moon at 5/14/2023, 3:02:00 AM
     */
    @Trace(operationName = "D3执行回写模板自定义执行周期起止时间定制答案(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementWriteBackstartAndEndTimeCustomResultComRespDto implementWriteBackstartAndEndTimeCustomResultCom(ImplementWriteBackstartAndEndTimeCustomResultComReqDto reqDto) {


        //virtualUsage 3-3-09查目标父周期开始与结束时间  41631
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:939248_1_41631
        queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:939249_1_41631
        queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode("TARGET");//sourceId:939250_1_41631
        queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:939251_1_41631
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:939253_1_41631
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getApplexId());//SimpleFieldAssign//sourceId:939252_1_41631
        }

        /*3-3-09查目标父周期开始与结束时间[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentTypeCode(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-关联目标内容类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-是否父周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage D2检查时间范围查询(公共)  41632
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
        if (omsEvaluationObjectTargetCycle != null) {
            CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
            if (reqDto != null) {
                checkTimeScopeSearchComReqDto.setCurrentTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939283_1_41632
            }
            if (omsEvaluationObjectTargetCycle != null) {
                checkTimeScopeSearchComReqDto.setCompareTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939285_1_41632
            }

            /*D2检查时间范围查询(公共)[3297]   */
            Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2检查时间范围查询(公共)-当前时间不能为空", false);
            Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2检查时间范围查询(公共)-比较时间不能为空", false);
            checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((!(checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")))) {
            //if(D2比较开始时间是否相同.时间比较结果 不等于 当前（等于）)  41633

            ImplementWriteBackSingleCustomResultComRespDto implementWriteBackSingleCustomResultComRespDto = null;
            ImplementWriteBackSingleCustomResultComReqDto implementWriteBackSingleCustomResultComReqDto = new ImplementWriteBackSingleCustomResultComReqDto();
            implementWriteBackSingleCustomResultComReqDto.setConfOptionCode("START_TIME");//CUSTOM_CONVENTION//sourceId:938961_1_41634
            implementWriteBackSingleCustomResultComReqDto.setConfItemCode("EVAL_SPECIAL_START_TIME_AND_END_TIME");//CUSTOM_CONVENTION//sourceId:938962_1_41634
            if (reqDto != null) {
                implementWriteBackSingleCustomResultComReqDto.setApplexId(reqDto.getApplexId());//SimpleFieldAssign//sourceId:938960_1_41634
                implementWriteBackSingleCustomResultComReqDto.setEndValue(reqDto.getCycleStartTime() != null ? String.valueOf(reqDto.getCycleStartTime()) : "");//SimpleFieldAssign//sourceId:938963_1_41634
            }

            /*D2执行回写单条定制答案(开始时间)[6653]   */
            Assert.isNull(implementWriteBackSingleCustomResultComReqDto.getApplexId(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(开始时间)-开通对象ID不能为空", false);
            Assert.isNull(implementWriteBackSingleCustomResultComReqDto.getEndValue(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(开始时间)-答案值不能为空", false);
            Assert.isNull(implementWriteBackSingleCustomResultComReqDto.getConfOptionCode(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(开始时间)-选项标识不能为空", false);
            Assert.isNull(implementWriteBackSingleCustomResultComReqDto.getConfItemCode(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(开始时间)-配置项标识不能为空", false);
            implementWriteBackSingleCustomResultComRespDto = fwCompSchemeOpenRecordClient.implementWriteBackSingleCustomResultCom(implementWriteBackSingleCustomResultComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage D2检查时间范围查询(公共)  41638
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
        if (omsEvaluationObjectTargetCycle != null) {
            CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1 = new CheckTimeScopeSearchComReqDto();
            if (reqDto != null) {
                checkTimeScopeSearchComReqDto_1.setCurrentTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939283_1_41638
            }
            if (omsEvaluationObjectTargetCycle != null) {
                checkTimeScopeSearchComReqDto_1.setCompareTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:939285_1_41638
            }

            /*D2检查时间范围查询(公共)[3297]   */
            Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2检查时间范围查询(公共)-当前时间不能为空", false);
            Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2检查时间范围查询(公共)-比较时间不能为空", false);
            checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((!(checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))) {
            //if(D2比较结束时间是否相同.时间比较结果 不等于 当前（等于）)  41639

            ImplementWriteBackSingleCustomResultComRespDto implementWriteBackSingleCustomResultComRespDto_1 = null;
            ImplementWriteBackSingleCustomResultComReqDto implementWriteBackSingleCustomResultComReqDto_1 = new ImplementWriteBackSingleCustomResultComReqDto();
            implementWriteBackSingleCustomResultComReqDto_1.setConfOptionCode("END_TIME");//CUSTOM_CONVENTION//sourceId:939137_1_41640
            implementWriteBackSingleCustomResultComReqDto_1.setConfItemCode("EVAL_SPECIAL_START_TIME_AND_END_TIME");//CUSTOM_CONVENTION//sourceId:939138_1_41640
            if (reqDto != null) {
                implementWriteBackSingleCustomResultComReqDto_1.setApplexId(reqDto.getApplexId());//SimpleFieldAssign//sourceId:939136_1_41640
                implementWriteBackSingleCustomResultComReqDto_1.setEndValue(reqDto.getCycleEndTime() != null ? String.valueOf(reqDto.getCycleEndTime()) : "");//SimpleFieldAssign//sourceId:939139_1_41640
            }

            /*D2执行回写单条定制答案(结束时间)[6653]   */
            Assert.isNull(implementWriteBackSingleCustomResultComReqDto_1.getApplexId(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(结束时间)-开通对象ID不能为空", false);
            Assert.isNull(implementWriteBackSingleCustomResultComReqDto_1.getEndValue(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(结束时间)-答案值不能为空", false);
            Assert.isNull(implementWriteBackSingleCustomResultComReqDto_1.getConfOptionCode(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(结束时间)-选项标识不能为空", false);
            Assert.isNull(implementWriteBackSingleCustomResultComReqDto_1.getConfItemCode(), "D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(结束时间)-配置项标识不能为空", false);
            implementWriteBackSingleCustomResultComRespDto_1 = fwCompSchemeOpenRecordClient.implementWriteBackSingleCustomResultCom(implementWriteBackSingleCustomResultComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        ImplementWriteBackstartAndEndTimeCustomResultComRespDto retData = new ImplementWriteBackstartAndEndTimeCustomResultComRespDto();


        return retData;
    }

    /**
     * D3-执行周期补偿处理(公共)[6662]
     * gen by moon at 5/14/2023, 10:23:15 PM
     */
    @Trace(operationName = "D3-执行周期补偿处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementExecuteCycleCompensationComRespDto implementExecuteCycleCompensationCom(ImplementExecuteCycleCompensationComReqDto reqDto) {


        //virtualUsage 是否开启评价模板自定义执行周期起止时间  41645
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:939511_1_41645
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SPECIAL_START_TIME_AND_END_TIME");//CUSTOM_CONVENTION//sourceId:939510_1_41645
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:939519_1_41645
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939512_1_41645
        }

        /*是否开启评价模板自定义执行周期起止时间[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D3-执行周期补偿处理(公共)-是否开启评价模板自定义执行周期起止时间-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D3-执行周期补偿处理(公共)-是否开启评价模板自定义执行周期起止时间-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3-执行周期补偿处理(公共)-是否开启评价模板自定义执行周期起止时间-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3-执行周期补偿处理(公共)-是否开启评价模板自定义执行周期起止时间-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage 3-3-09查被评对象目标周期详情  41653
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:939744_1_41653
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:939746_1_41653
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939745_1_41653
        }

        /*3-3-09查被评对象目标周期详情[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行周期补偿处理(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(), "D3-执行周期补偿处理(公共)-3-3-09查被评对象目标周期详情-是否父周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行周期补偿处理(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("TRUE"))) {
            //if(是否开启评价模板自定义执行周期起止时间.答案值 等于 是)  41646

            ImplementExecuteFatherCycleAnalysisByCustomizeComRespDto implementExecuteFatherCycleAnalysisByCustomizeComRespDto = null;
            if (omsEvaluationObjectTargetCycle != null) {
                ImplementExecuteFatherCycleAnalysisByCustomizeComReqDto implementExecuteFatherCycleAnalysisByCustomizeComReqDto = new ImplementExecuteFatherCycleAnalysisByCustomizeComReqDto();
                if (reqDto != null) {
                    implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:939294_1_41648
                    implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setComTimeField2(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:939295_1_41648
                    implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939296_1_41648
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939754_1_41648
                    implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:939755_1_41648
                }

                /*D3-执行根据自定义分析父周期(公共)[6654]   */
                Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getComTimeField1(), "D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-前端录入父周期开始时间不能为空", false);
                Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getComTimeField2(), "D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-前端录入父周期结束时间不能为空", false);
                Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getCycleStartTime(), "D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-父周期周期开始时间不能为空", false);
                Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getCycleEndTime(), "D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-父周期周期结束时间不能为空", false);
                Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getEvaluationTemplateId(), "D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-冗余评价模板ID不能为空", false);
                implementExecuteFatherCycleAnalysisByCustomizeComRespDto = implementExecuteFatherCycleAnalysisByCustomizeCom(implementExecuteFatherCycleAnalysisByCustomizeComReqDto)/*vcase invoke 同服务,同domain*/;


            }
            if ((implementExecuteFatherCycleAnalysisByCustomizeComRespDto != null && implementExecuteFatherCycleAnalysisByCustomizeComRespDto.getFatherCycleStartTimeIsModify() != null && implementExecuteFatherCycleAnalysisByCustomizeComRespDto.getFatherCycleStartTimeIsModify().equals("TRUE") || implementExecuteFatherCycleAnalysisByCustomizeComRespDto != null && implementExecuteFatherCycleAnalysisByCustomizeComRespDto.getFatherCycleEndTimeIsModify() != null && implementExecuteFatherCycleAnalysisByCustomizeComRespDto.getFatherCycleEndTimeIsModify().equals("TRUE"))) {
                //if((D3-执行周期父周期分析(公共).父周期开始时间是否定制 等于 是 or D3-执行周期父周期分析(公共).父周期结束时间是否定制 等于 是))  41649

                ImplementDeletProgressCycleComRespDto implementDeletProgressCycleComRespDto = null;
                if (omsEvaluationObjectTargetCycle != null) {
                    ImplementDeletProgressCycleComReqDto implementDeletProgressCycleComReqDto = new ImplementDeletProgressCycleComReqDto();
                    if (reqDto != null) {
                        implementDeletProgressCycleComReqDto.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:939301_1_41650
                        implementDeletProgressCycleComReqDto.setComTimeField2(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:939302_1_41650
                        implementDeletProgressCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939305_1_41650
                    }
                    if (omsEvaluationObjectTargetCycle != null) {
                        implementDeletProgressCycleComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939303_1_41650
                        implementDeletProgressCycleComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:939304_1_41650
                    }

                    /*D3-执行回删过程执行周期(公共)[6658]   */
                    Assert.isNull(implementDeletProgressCycleComReqDto.getCycleStartTime(), "D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-父周期周期开始时间不能为空", false);
                    Assert.isNull(implementDeletProgressCycleComReqDto.getCycleEndTime(), "D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-父周期周期结束时间不能为空", false);
                    Assert.isNull(implementDeletProgressCycleComReqDto.getEvaluationTemplateId(), "D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-评价模板ID不能为空", false);
                    implementDeletProgressCycleComRespDto = implementDeletProgressCycleCom(implementDeletProgressCycleComReqDto)/*vcase invoke 同服务,同domain*/;


                }
            }
        } else if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("FALSE"))) {
            //elseif(是否开启评价模板自定义执行周期起止时间.答案值 等于 否)  41647

            ImplementExecuteFatherCycleAnalysisByHolidayComRespDto implementExecuteFatherCycleAnalysisByHolidayComRespDto = null;
            if (omsEvaluationObjectTargetCycle != null) {
                ImplementExecuteFatherCycleAnalysisByHolidayComReqDto implementExecuteFatherCycleAnalysisByHolidayComReqDto = new ImplementExecuteFatherCycleAnalysisByHolidayComReqDto();
                if (omsEvaluationObjectTargetCycle != null) {
                    implementExecuteFatherCycleAnalysisByHolidayComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:940327_1_41673
                    implementExecuteFatherCycleAnalysisByHolidayComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:940328_1_41673
                }

                /*D3-执行根据节假日分析父周期(公共)[6665]   */
                Assert.isNull(implementExecuteFatherCycleAnalysisByHolidayComReqDto.getCycleStartTime(), "D3-执行周期补偿处理(公共)-D3-执行根据节假日分析父周期(公共)-父周期周期开始时间不能为空", false);
                Assert.isNull(implementExecuteFatherCycleAnalysisByHolidayComReqDto.getCycleEndTime(), "D3-执行周期补偿处理(公共)-D3-执行根据节假日分析父周期(公共)-父周期周期结束时间不能为空", false);
                implementExecuteFatherCycleAnalysisByHolidayComRespDto = implementExecuteFatherCycleAnalysisByHolidayCom(implementExecuteFatherCycleAnalysisByHolidayComReqDto)/*vcase invoke 同服务,同domain*/;


            }
            ImplementDeletProgressCycleComRespDto implementDeletProgressCycleComRespDto_1 = null;
            if (implementExecuteFatherCycleAnalysisByHolidayComRespDto != null && omsEvaluationObjectTargetCycle != null) {
                ImplementDeletProgressCycleComReqDto implementDeletProgressCycleComReqDto_1 = new ImplementDeletProgressCycleComReqDto();
                if (implementExecuteFatherCycleAnalysisByHolidayComRespDto != null) {
                    implementDeletProgressCycleComReqDto_1.setComTimeField1(implementExecuteFatherCycleAnalysisByHolidayComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939301_1_41674
                    implementDeletProgressCycleComReqDto_1.setComTimeField2(implementExecuteFatherCycleAnalysisByHolidayComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939302_1_41674
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    implementDeletProgressCycleComReqDto_1.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939303_1_41674
                    implementDeletProgressCycleComReqDto_1.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:939304_1_41674
                }
                if (reqDto != null) {
                    implementDeletProgressCycleComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939305_1_41674
                }

                /*D3-执行回删过程执行周期(公共)[6658]   */
                Assert.isNull(implementDeletProgressCycleComReqDto_1.getCycleStartTime(), "D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-父周期周期开始时间不能为空", false);
                Assert.isNull(implementDeletProgressCycleComReqDto_1.getCycleEndTime(), "D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-父周期周期结束时间不能为空", false);
                Assert.isNull(implementDeletProgressCycleComReqDto_1.getEvaluationTemplateId(), "D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-评价模板ID不能为空", false);
                implementDeletProgressCycleComRespDto_1 = implementDeletProgressCycleCom(implementDeletProgressCycleComReqDto_1)/*vcase invoke 同服务,同domain*/;


            }
        }
        ImplementExecuteCycleCompensationComRespDto retData = new ImplementExecuteCycleCompensationComRespDto();


        return retData;
    }

    /**
     * D3-执行根据节假日分析父周期(公共)[6665]
     * gen by moon at 5/14/2023, 6:20:07 PM
     */
    @Trace(operationName = "D3-执行根据节假日分析父周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementExecuteFatherCycleAnalysisByHolidayComRespDto implementExecuteFatherCycleAnalysisByHolidayCom(ImplementExecuteFatherCycleAnalysisByHolidayComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
//virtualUsage 3-4-04查询最小周期（标准工作日）  41662
        OmsCycle omsCycle = null;
        QueryMinimumCycleDetailReq queryMinimumCycleDetailReq = new QueryMinimumCycleDetailReq();
        queryMinimumCycleDetailReq.setCycleTypeCode("WEEKDAY");//CUSTOM_CONVENTION//sourceId:939960_1_41662
        queryMinimumCycleDetailReq.setCycleTypeStandard("STANDARD");//sourceId:939978_1_41662
        queryMinimumCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:939963_1_41662
        if (reqDto != null) {
            queryMinimumCycleDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939958_1_41662
            queryMinimumCycleDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939959_1_41662
        }

        /*3-4-04查询最小周期（标准工作日）[6663]   */
        Assert.isNull(queryMinimumCycleDetailReq.getCycleStartTime(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（标准工作日）-周期开始时间不能为空", false);
        Assert.isNull(queryMinimumCycleDetailReq.getCycleEndTime(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（标准工作日）-周期结束时间不能为空", false);
        Assert.isNull(queryMinimumCycleDetailReq.getCycleTypeCode(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（标准工作日）-周期类型标识不能为空", false);
        Assert.isNull(queryMinimumCycleDetailReq.getSubjectLifeCycle(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（标准工作日）-主体生命周期不能为空", false);
        omsCycle = mOmsCycleService.queryMinimumCycleDetail(queryMinimumCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-4-04查询最小周期（自定义工作日）  41664
        OmsCycle omsCycle_2 = null;
        QueryMinimumCycleDetailReq queryMinimumCycleDetailReq_1 = new QueryMinimumCycleDetailReq();
        queryMinimumCycleDetailReq_1.setCycleTypeCode("CUSTOM_WEEKDAY");//CUSTOM_CONVENTION//sourceId:940002_1_41664
        queryMinimumCycleDetailReq_1.setCycleTypeStandard("IRREGULAR");//sourceId:940019_1_41664
        queryMinimumCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:940005_1_41664
        queryMinimumCycleDetailReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:940818_1_41664
        if (reqDto != null) {
            queryMinimumCycleDetailReq_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:940000_1_41664
            queryMinimumCycleDetailReq_1.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:940001_1_41664
        }

        /*3-4-04查询最小周期（自定义工作日）[6663]   */
        Assert.isNull(queryMinimumCycleDetailReq_1.getCycleStartTime(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-周期开始时间不能为空", false);
        Assert.isNull(queryMinimumCycleDetailReq_1.getCycleEndTime(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-周期结束时间不能为空", false);
        Assert.isNull(queryMinimumCycleDetailReq_1.getCycleTypeCode(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-周期类型标识不能为空", false);
        Assert.isNull(queryMinimumCycleDetailReq_1.getCycleTypeStandard(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-冗余周期类型标准化不能为空", false);
        Assert.isNull(queryMinimumCycleDetailReq_1.getSubjectLifeCycle(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-主体生命周期不能为空", false);
        Assert.isNull(queryMinimumCycleDetailReq_1.getSpaceId(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-创建于空间ID不能为空", false);
        omsCycle_2 = mOmsCycleService.queryMinimumCycleDetail(queryMinimumCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsCycle_2 == null)) {
            //if(3-4-04查询最小周期（自定义工作日）.出参 值等于空 )  41701

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            if (omsCycle != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
                if (omsCycle != null) {
                    receptionServiceReq.setCycleStartTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:940181_1_41702
                }

                /*约定出参：周期开始时间[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getCycleStartTime(), "D3-执行根据节假日分析父周期(公共)-约定出参：周期开始时间-周期开始时间不能为空", false);
                receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        }
//virtualUsage D2检查时间范围查询(公共)  41665
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
        if (omsCycle != null && omsCycle_2 != null) {
            CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
            if (omsCycle != null) {
                checkTimeScopeSearchComReqDto.setCurrentTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939955_1_41665
            }
            if (omsCycle_2 != null) {
                checkTimeScopeSearchComReqDto.setCompareTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:939957_1_41665
            }

            /*D2检查时间范围查询(公共)[3297]   */
            Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3-执行根据节假日分析父周期(公共)-D2检查时间范围查询(公共)-当前时间不能为空", false);
            Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3-执行根据节假日分析父周期(公共)-D2检查时间范围查询(公共)-比较时间不能为空", false);
            checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("BEFORE") || checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))) {
            //if((D2标准工作日与自定义工作日最小比较.时间比较结果 等于 之前（小于） or D2标准工作日与自定义工作日最小比较.时间比较结果 等于 当前（等于）))  41666

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            if (omsCycle != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                if (omsCycle != null) {
                    receptionServiceReq_1.setCycleStartTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:940181_1_41669
                }

                /*约定出参：周期开始时间[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getCycleStartTime(), "D3-执行根据节假日分析父周期(公共)-约定出参：周期开始时间-周期开始时间不能为空", false);
                receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        } else if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))) {
            //elseif(D2标准工作日与自定义工作日最小比较.时间比较结果 等于 之后（大于）)  41697

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
            if (omsCycle_2 != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
                if (omsCycle_2 != null) {
                    receptionServiceReq_2.setCycleStartTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:940181_1_41698
                }

                /*约定出参：周期开始时间[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getCycleStartTime(), "D3-执行根据节假日分析父周期(公共)-约定出参：周期开始时间-周期开始时间不能为空", false);
                receptionServiceRes_3 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


                receptionServiceRes_1 = receptionServiceRes_3;
            }
        }
//virtualUsage 3-4-04查询最大周期（标准工作日）  41667
        OmsCycle omsCycle_4 = null;
        QueryMaximumCycleDetailReq queryMaximumCycleDetailReq = new QueryMaximumCycleDetailReq();
        queryMaximumCycleDetailReq.setCycleTypeCode("WEEKDAY");//CUSTOM_CONVENTION//sourceId:939998_1_41667
        queryMaximumCycleDetailReq.setCycleTypeStandard("STANDARD");//sourceId:939999_1_41667
        queryMaximumCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:939983_1_41667
        if (reqDto != null) {
            queryMaximumCycleDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939979_1_41667
            queryMaximumCycleDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939980_1_41667
        }

        /*3-4-04查询最大周期（标准工作日）[6664]   */
        Assert.isNull(queryMaximumCycleDetailReq.getCycleStartTime(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-周期开始时间不能为空", false);
        Assert.isNull(queryMaximumCycleDetailReq.getCycleEndTime(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-周期结束时间不能为空", false);
        Assert.isNull(queryMaximumCycleDetailReq.getCycleTypeCode(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-周期类型标识不能为空", false);
        Assert.isNull(queryMaximumCycleDetailReq.getCycleTypeStandard(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-冗余周期类型标准化不能为空", false);
        Assert.isNull(queryMaximumCycleDetailReq.getSubjectLifeCycle(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-主体生命周期不能为空", false);
        omsCycle_4 = mOmsCycleService.queryMaximumCycleDetail(queryMaximumCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-4-04查询最大周期（自定义工作日）  41668
        OmsCycle omsCycle_6 = null;
        QueryMaximumCycleDetailReq queryMaximumCycleDetailReq_1 = new QueryMaximumCycleDetailReq();
        queryMaximumCycleDetailReq_1.setCycleTypeCode("CUSTOM_WEEKDAY");//CUSTOM_CONVENTION//sourceId:940038_1_41668
        queryMaximumCycleDetailReq_1.setCycleTypeStandard("IRREGULAR");//sourceId:940037_1_41668
        queryMaximumCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:940024_1_41668
        queryMaximumCycleDetailReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:940819_1_41668
        if (reqDto != null) {
            queryMaximumCycleDetailReq_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:940020_1_41668
            queryMaximumCycleDetailReq_1.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:940021_1_41668
        }

        /*3-4-04查询最大周期（自定义工作日）[6664]   */
        Assert.isNull(queryMaximumCycleDetailReq_1.getCycleStartTime(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-周期开始时间不能为空", false);
        Assert.isNull(queryMaximumCycleDetailReq_1.getCycleEndTime(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-周期结束时间不能为空", false);
        Assert.isNull(queryMaximumCycleDetailReq_1.getCycleTypeCode(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-周期类型标识不能为空", false);
        Assert.isNull(queryMaximumCycleDetailReq_1.getCycleTypeStandard(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-冗余周期类型标准化不能为空", false);
        Assert.isNull(queryMaximumCycleDetailReq_1.getSubjectLifeCycle(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-主体生命周期不能为空", false);
        Assert.isNull(queryMaximumCycleDetailReq_1.getSpaceId(), "D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-创建于空间ID不能为空", false);
        omsCycle_6 = mOmsCycleService.queryMaximumCycleDetail(queryMaximumCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsCycle_6 == null)) {
            //if(3-4-04查询最大周期（自定义工作日）.出参 值等于空 )  41703

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            if (omsCycle_4 != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
                if (omsCycle_4 != null) {
                    receptionServiceReq_3.setCycleEndTime(omsCycle_4.getCycleEndTime());//SimpleFieldAssign//sourceId:940321_1_41704
                }

                /*约定出参：周期结束时间[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getCycleEndTime(), "D3-执行根据节假日分析父周期(公共)-约定出参：周期结束时间-周期结束时间不能为空", false);
                receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


                receptionServiceRes_5 = receptionServiceRes_4;
            }
        }
//virtualUsage D2检查时间范围查询(公共)  41670
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
        if (omsCycle_4 != null && omsCycle_6 != null) {
            CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1 = new CheckTimeScopeSearchComReqDto();
            if (omsCycle_4 != null) {
                checkTimeScopeSearchComReqDto_1.setCurrentTime(omsCycle_4.getCycleEndTime());//SimpleFieldAssign//sourceId:939955_1_41670
            }
            if (omsCycle_6 != null) {
                checkTimeScopeSearchComReqDto_1.setCompareTime(omsCycle_6.getCycleEndTime());//SimpleFieldAssign//sourceId:939957_1_41670
            }

            /*D2检查时间范围查询(公共)[3297]   */
            Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(), "D3-执行根据节假日分析父周期(公共)-D2检查时间范围查询(公共)-当前时间不能为空", false);
            Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(), "D3-执行根据节假日分析父周期(公共)-D2检查时间范围查询(公共)-比较时间不能为空", false);
            checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("BEFORE") || checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT"))) {
            //if((D2标准工作日与自定义工作日最大比较.时间比较结果 等于 之前（小于） or D2标准工作日与自定义工作日最大比较.时间比较结果 等于 当前（等于）))  41671

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
            if (omsCycle_6 != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
                if (omsCycle_6 != null) {
                    receptionServiceReq_4.setCycleEndTime(omsCycle_6.getCycleEndTime());//SimpleFieldAssign//sourceId:940321_1_41672
                }

                /*约定出参：周期结束时间[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_4.getCycleEndTime(), "D3-执行根据节假日分析父周期(公共)-约定出参：周期结束时间-周期结束时间不能为空", false);
                receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_4);


                receptionServiceRes_5 = receptionServiceRes_6;
            }
        } else if ((checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("LATER"))) {
            //elseif(D2标准工作日与自定义工作日最大比较.时间比较结果 等于 之后（大于）)  41699

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
            if (omsCycle_4 != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_5 = new CalculateAcceptAboveFieldsReqDto();
                if (omsCycle_4 != null) {
                    receptionServiceReq_5.setCycleEndTime(omsCycle_4.getCycleEndTime());//SimpleFieldAssign//sourceId:940321_1_41700
                }

                /*约定出参：周期结束时间[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_5.getCycleEndTime(), "D3-执行根据节假日分析父周期(公共)-约定出参：周期结束时间-周期结束时间不能为空", false);
                receptionServiceRes_7 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_5);


                receptionServiceRes_5 = receptionServiceRes_7;
            }
        }
        ImplementExecuteFatherCycleAnalysisByHolidayComRespDto retData = new ImplementExecuteFatherCycleAnalysisByHolidayComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setCycleStartTime(receptionServiceRes_1.getCycleStartTime());//SimpleFieldAssign//sourceId:940323_1
        }
        if (receptionServiceRes_5 != null) {
            retData.setCycleEndTime(receptionServiceRes_5.getCycleEndTime());//SimpleFieldAssign//sourceId:940324_1
        }


        return retData;
    }

    /**
     * D3-分析当前周期类型是否末级周期类型(公共)[6887]
     * gen by moon at 5/21/2023, 6:37:20 AM
     */
    @Trace(operationName = "D3-分析当前周期类型是否末级周期类型(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalysisIsLastCycleTypeComRespDto implementAnalysisIsLastCycleTypeCom(ImplementAnalysisIsLastCycleTypeComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
//virtualUsage D2-执行字符串对比(公共)  42438
        ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
        ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto = new ImplementStringEfficiencyCheckComReqDto();
        if (reqDto != null) {
            implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:966818_1_42438
            implementStringEfficiencyCheckComReqDto.setComparisonString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:966819_1_42438
        }

        /*D2-执行字符串对比(公共)[5774]   */

        implementStringEfficiencyCheckComRespDto = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))) {
            //if(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 是)  42439

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
            receptionServiceReq.setTureOrFalse("TRUE");//sourceId:966788_1_42443

            /*约定：是[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getTureOrFalse(), "D3-分析当前周期类型是否末级周期类型(公共)-约定：是-是否不能为空", false);
            receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:967117_1_42444
            }

            /*约定出参：是否末级周期类型[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getTureOrFalse(), "D3-分析当前周期类型是否末级周期类型(公共)-约定出参：是否末级周期类型-是否不能为空", false);
            receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE")) || (reqDto != null && reqDto.getLastCycleType() == null && reqDto != null && reqDto.getCycleTypeCode() != null)) {
            //elseif(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 否 or (D3-分析当前周期类型是否末级周期类型(公共).末级周期类型 值等于空  and D3-分析当前周期类型是否末级周期类型(公共).周期类型标识 值不等于空 ))  42445

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            receptionServiceReq_2.setTureOrFalse("FALSE");//sourceId:966790_1_42446

            /*约定：否[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getTureOrFalse(), "D3-分析当前周期类型是否末级周期类型(公共)-约定：否-是否不能为空", false);
            receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes_4 != null) {
                receptionServiceReq_3.setTureOrFalse(receptionServiceRes_4.getTureOrFalse());//SimpleFieldAssign//sourceId:967117_1_42447
            }

            /*约定出参：是否末级周期类型[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getTureOrFalse(), "D3-分析当前周期类型是否末级周期类型(公共)-约定出参：是否末级周期类型-是否不能为空", false);
            receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


            receptionServiceRes_3 = receptionServiceRes_6;
        }
        ImplementAnalysisIsLastCycleTypeComRespDto retData = new ImplementAnalysisIsLastCycleTypeComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setTureOrFalse(receptionServiceRes_3.getTureOrFalse());//SimpleFieldAssign//sourceId:967127_1
        }


        return retData;
    }

    /**
     * D3获取目标内容计划工作时间[6867]
     * gen by moon at 4/28/2024, 2:57:01 PM
     */
    @Trace(operationName = "D3获取目标内容计划工作时间")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainTargetContPlanWorkTimeRespDto obtainTargetContPlanWorkTime(ObtainTargetContPlanWorkTimeReqDto reqDto) {


        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 = null;
        ObtainTargetContIsOpenCustomReportComRespDto obtainTargetContIsOpenCustomReportComRespDto_1 = null;
        AnalysisCutCycleReportTimeTypeCodeComRespDto analysisCutCycleReportTimeTypeCodeComRespDto_1 = null;
        QueryCustomReportWorkCycleListComRespDto queryCustomReportWorkCycleListComRespDto_1 = null;
//virtualUsage D2查是否开启自定义汇报配置参数  51438
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_CUSTOM_REPORT");//CUSTOM_CONVENTION//sourceId:1221574_1_51438
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1221575_1_51438
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1221573_1_51438
        }

        /*D2查是否开启自定义汇报配置参数[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D3获取目标内容计划工作时间-D2查是否开启自定义汇报配置参数-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3获取目标内容计划工作时间-D2查是否开启自定义汇报配置参数-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3获取目标内容计划工作时间-D2查是否开启自定义汇报配置参数-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
//virtualUsage D3获取目标内容是否开启自定义汇报(公共)  45086
        ObtainTargetContIsOpenCustomReportComRespDto obtainTargetContIsOpenCustomReportComRespDto = null;
        ObtainTargetContIsOpenCustomReportComReqDto obtainTargetContIsOpenCustomReportComReqDto = new ObtainTargetContIsOpenCustomReportComReqDto();
        if (reqDto != null) {
            obtainTargetContIsOpenCustomReportComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:981760_1_45086
            obtainTargetContIsOpenCustomReportComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:981761_1_45086
            obtainTargetContIsOpenCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:981762_1_45086
        }

        /*D3获取目标内容是否开启自定义汇报(公共)[6949]   */
        Assert.isNull(obtainTargetContIsOpenCustomReportComReqDto.getEntityId(), "D3获取目标内容计划工作时间-D3获取目标内容是否开启自定义汇报(公共)-内容表主键ID不能为空", false);
        Assert.isNull(obtainTargetContIsOpenCustomReportComReqDto.getTableTypeCode(), "D3获取目标内容计划工作时间-D3获取目标内容是否开启自定义汇报(公共)-内容表类型编码不能为空", false);
        Assert.isNull(obtainTargetContIsOpenCustomReportComReqDto.getEvaluationTemplateId(), "D3获取目标内容计划工作时间-D3获取目标内容是否开启自定义汇报(公共)-冗余评价模板ID不能为空", false);
        obtainTargetContIsOpenCustomReportComRespDto = indexSystemService.obtainTargetContIsOpenCustomReportCom(obtainTargetContIsOpenCustomReportComReqDto)/*vcase invoke isSameApp*/;


        obtainTargetContIsOpenCustomReportComRespDto_1 = obtainTargetContIsOpenCustomReportComRespDto;
//virtualUsage 3-3-09查当前内容目标子周期类型  67632
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:961774_1_67632
        queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:961775_1_67632
        queryEvaObjTargetCycleDetailReq.setIsSubCycle("TRUE");//sourceId:961777_1_67632
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:961779_1_67632
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:961776_1_67632
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:961778_1_67632
        }

        /*3-3-09查当前内容目标子周期类型[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsSubCycle(), "D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-是否子周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage D3分析裁剪子周期汇报时间类型(公共)  67631
        AnalysisCutCycleReportTimeTypeCodeComRespDto analysisCutCycleReportTimeTypeCodeComRespDto = null;
        if (omsEvaluationObjectTargetCycle != null) {
            AnalysisCutCycleReportTimeTypeCodeComReqDto analysisCutCycleReportTimeTypeCodeComReqDto = new AnalysisCutCycleReportTimeTypeCodeComReqDto();
            if (omsEvaluationObjectTargetCycle != null) {
                analysisCutCycleReportTimeTypeCodeComReqDto.setSubcycleType(omsEvaluationObjectTargetCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1760294_1_67631
            }

            /*D3分析裁剪子周期汇报时间类型(公共)[9456]   */
            Assert.isNull(analysisCutCycleReportTimeTypeCodeComReqDto.getSubcycleType(), "D3获取目标内容计划工作时间-D3分析裁剪子周期汇报时间类型(公共)-子周期周期类型不能为空", false);
            analysisCutCycleReportTimeTypeCodeComRespDto = analysisCutCycleReportTimeTypeCodeCom(analysisCutCycleReportTimeTypeCodeComReqDto)/*vcase invoke 同服务,同domain*/;


            analysisCutCycleReportTimeTypeCodeComRespDto_1 = analysisCutCycleReportTimeTypeCodeComRespDto;
        }
//virtualUsage D3查询自定义汇报工作周期列表(公共)  67637
        QueryCustomReportWorkCycleListComRespDto queryCustomReportWorkCycleListComRespDto = null;
        QueryCustomReportWorkCycleListComReqDto queryCustomReportWorkCycleListComReqDto = new QueryCustomReportWorkCycleListComReqDto();
        queryCustomReportWorkCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1761552_1_67637
        queryCustomReportWorkCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1761553_1_67637
        if (reqDto != null) {
            queryCustomReportWorkCycleListComReqDto.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1761551_1_67637
            queryCustomReportWorkCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761550_1_67637
        }

        /*D3查询自定义汇报工作周期列表(公共)[9458]   */
        Assert.isNull(queryCustomReportWorkCycleListComReqDto.getEvaObjEntityId(), "D3获取目标内容计划工作时间-D3查询自定义汇报工作周期列表(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryCustomReportWorkCycleListComReqDto.getEvaObjTypeCode(), "D3获取目标内容计划工作时间-D3查询自定义汇报工作周期列表(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(queryCustomReportWorkCycleListComReqDto.getTargetCycleContentId(), "D3获取目标内容计划工作时间-D3查询自定义汇报工作周期列表(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(queryCustomReportWorkCycleListComReqDto.getEvaluationTemplateId(), "D3获取目标内容计划工作时间-D3查询自定义汇报工作周期列表(公共)-冗余评价模板ID不能为空", false);
        queryCustomReportWorkCycleListComRespDto = queryCustomReportWorkCycleListCom(queryCustomReportWorkCycleListComReqDto)/*vcase invoke 同服务,同domain*/;


        queryCustomReportWorkCycleListComRespDto_1 = queryCustomReportWorkCycleListComRespDto;
        ObtainTargetContPlanWorkTimeRespDto retData = new ObtainTargetContPlanWorkTimeRespDto();
        if (queryCustomReportWorkCycleListComRespDto_1 != null) {
            retData.setTargetContPlanWorkTimeList(queryCustomReportWorkCycleListComRespDto_1.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1761557_1
            retData.setTargetCycleParentCycleId(queryCustomReportWorkCycleListComRespDto_1.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1761558_1
            retData.setTargetCycleMidCycleId(queryCustomReportWorkCycleListComRespDto_1.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:1761559_1
        }
        if (analysisCutCycleReportTimeTypeCodeComRespDto_1 != null) {
            retData.setCutCycleReportTimeTypeCode(analysisCutCycleReportTimeTypeCodeComRespDto_1.getCutCycleReportTimeTypeCode());//SimpleFieldAssign//sourceId:1760636_1
        }
        if (obtainTargetContIsOpenCustomReportComRespDto_1 != null) {
            retData.setIsOpenCustomReport(obtainTargetContIsOpenCustomReportComRespDto_1.getIsOpenCustomReport());//SimpleFieldAssign//sourceId:981764_1
        }
        if (queryConfItemMatchAnswerDetailComRespDto_1 != null) {
            retData.setTempIsOpenCustomReport(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:1221577_1
        }


        return retData;
    }

    /**
     * D3设置目标内容成果汇报时间(公共)[6868]
     * gen by moon at 4/28/2024, 2:33:01 PM
     */
    @Trace(operationName = "D3设置目标内容成果汇报时间(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public SetTargetContActualWorkTimeComRespDto setTargetContActualWorkTimeCom(SetTargetContActualWorkTimeComReqDto reqDto) {


        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 = null;
        ImplementWriteBackTargetContCustomReportComRespDto implementWriteBackTargetContCustomReportComRespDto_1 = null;
//virtualUsage 3-3-09查目标父周期  42937
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:963302_1_42937
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:963300_1_42937
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:963301_1_42937
        }

        /*3-3-09查目标父周期[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3设置目标内容成果汇报时间(公共)-3-3-09查目标父周期-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3设置目标内容成果汇报时间(公共)-3-3-09查目标父周期-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3设置目标内容成果汇报时间(公共)-3-3-09查目标父周期-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
        if ((reqDto != null && reqDto.getTargetCyclePsetList() != null && reqDto.getTargetCyclePsetList().size() > 0)) {
            //if(D3设置目标内容成果汇报时间(公共).目标周期规划设置列表数据集条数 大于 0)  42320

            boolean bOOLEAN;
            List<OmsTargetCyclePlanSet> listOmsTargetCyclePlanSet = new ArrayList<>();
            if (reqDto != null && reqDto.getTargetCyclePsetList() != null && !CollectionUtil.isEmpty(reqDto.getTargetCyclePsetList())) {
                listOmsTargetCyclePlanSet = //objList-to-objLists
                        reqDto.getTargetCyclePsetList().stream().map(item -> {
                            OmsTargetCyclePlanSet elm = new OmsTargetCyclePlanSet();
                            if (item != null) {
                                elm.setTargetCyclePlanSetId(item.getTargetCyclePlanSetId());//SimpleFieldAssign//sourceId:205265_2_42321
                                elm.setTargetActualStartTime(item.getTargetActualStartTime());//SimpleFieldAssign//sourceId:205266_2_42321
                                elm.setTargetActualEndtTime(item.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:205267_2_42321
                                elm.setAcceptancePlanTime(item.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:205769_2_42321
                            }
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:963788_1_42321
            }

            /*3-3-08批量改目标子周期规划设置[3596]   */

            bOOLEAN = mOmsTargetCyclePlanSetService.batchUpdateTargetCyclePset(listOmsTargetCyclePlanSet)/*vcase invoke 本地 method 方法调用;*/;


            ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeComRespDto = null;
            ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto implementOverwriteTargetContFatherOrMidReportTimeComReqDto = new ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto();
            if (reqDto != null) {
                implementOverwriteTargetContFatherOrMidReportTimeComReqDto.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1760648_1_67633
                implementOverwriteTargetContFatherOrMidReportTimeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1760647_1_67633
            }

            /*D3回写目标内容父或中成果汇报时间(公共)[9450]   */
            Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto.getEvaObjTargetCycleId(), "D3设置目标内容成果汇报时间(公共)-D3回写目标内容父或中成果汇报时间(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto.getEvaluationTemplateId(), "D3设置目标内容成果汇报时间(公共)-D3回写目标内容父或中成果汇报时间(公共)-冗余评价模板ID不能为空", false);
            implementOverwriteTargetContFatherOrMidReportTimeComRespDto = implementOverwriteTargetContFatherOrMidReportTimeCom(implementOverwriteTargetContFatherOrMidReportTimeComReqDto)/*vcase invoke 同服务,同domain*/;


            if ((reqDto != null && reqDto.getTargetCycleMidCycleId() != null)) {
                //if(D3设置目标内容成果汇报时间(公共).目标周期中期ID 值不等于空 )  67634

                ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeComRespDto_1 = null;
                ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1 = new ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto();
                if (reqDto != null) {
                    implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:1760648_1_67635
                    implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1760647_1_67635
                }

                /*D3回写目标内容父或中成果汇报时间(公共)[9450]   */
                Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.getEvaObjTargetCycleId(), "D3设置目标内容成果汇报时间(公共)-D3回写目标内容父或中成果汇报时间(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.getEvaluationTemplateId(), "D3设置目标内容成果汇报时间(公共)-D3回写目标内容父或中成果汇报时间(公共)-冗余评价模板ID不能为空", false);
                implementOverwriteTargetContFatherOrMidReportTimeComRespDto_1 = implementOverwriteTargetContFatherOrMidReportTimeCom(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1)/*vcase invoke 同服务,同domain*/;


            }
            ImplementWriteBackTargetContCustomReportComRespDto implementWriteBackTargetContCustomReportComRespDto = null;
            ImplementWriteBackTargetContCustomReportComReqDto implementWriteBackTargetContCustomReportComReqDto = new ImplementWriteBackTargetContCustomReportComReqDto();
            if (reqDto != null) {
                implementWriteBackTargetContCustomReportComReqDto.setTargetCycleParentCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:968645_1_67636
                implementWriteBackTargetContCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:968644_1_67636
            }

            /*D3执行回写目标内容自定义汇报(公共)[6892]   */
            Assert.isNull(implementWriteBackTargetContCustomReportComReqDto.getTargetCycleParentCycleId(), "D3设置目标内容成果汇报时间(公共)-D3执行回写目标内容自定义汇报(公共)-目标周期父周期ID不能为空", false);
            Assert.isNull(implementWriteBackTargetContCustomReportComReqDto.getEvaluationTemplateId(), "D3设置目标内容成果汇报时间(公共)-D3执行回写目标内容自定义汇报(公共)-冗余评价模板ID不能为空", false);
            implementWriteBackTargetContCustomReportComRespDto = targetCycleService.implementWriteBackTargetContCustomReportCom(implementWriteBackTargetContCustomReportComReqDto)/*vcase invoke isSameApp*/;


            implementWriteBackTargetContCustomReportComRespDto_1 = implementWriteBackTargetContCustomReportComRespDto;
        }
        SetTargetContActualWorkTimeComRespDto retData = new SetTargetContActualWorkTimeComRespDto();
        if (omsEvaluationObjectTargetCycle_1 != null) {
            retData.setCyclelAlias(omsEvaluationObjectTargetCycle_1.getCyclelAlias());//SimpleFieldAssign//sourceId:1151091_1
            retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:980550_1
            retData.setTargetCycleContentTypeCode(omsEvaluationObjectTargetCycle_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:980553_1
            retData.setTargetId(omsEvaluationObjectTargetCycle_1.getTargetId());//SimpleFieldAssign//sourceId:980554_1
        }
        if (implementWriteBackTargetContCustomReportComRespDto_1 != null) {
            retData.setIsOpenCustomReport(implementWriteBackTargetContCustomReportComRespDto_1.getIsOpenCustomReport());//SimpleFieldAssign//sourceId:971155_1
        }


        return retData;
    }

    /**
     * D3-新增标准执行周期阶段(公共)[6870]
     * gen by moon at 7/6/2024, 11:56:48 PM
     */
    @Trace(operationName = "D3-新增标准执行周期阶段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddStandardExecuteCycleStageComComRespDto addStandardExecuteCycleStageComCom(AddStandardExecuteCycleStageComComReqDto reqDto) {


        ImplementSpecProcessCycleIsOpenComRespDto implementSpecProcessCycleIsOpenComRespDto_1 = null;
        //virtualUsage D3-查周期类型相关配置(公共)  42957
        ImplementSpecProcessCycleIsOpenComRespDto implementSpecProcessCycleIsOpenComRespDto = null;
        ImplementSpecProcessCycleIsOpenComReqDto implementSpecProcessCycleIsOpenComReqDto = new ImplementSpecProcessCycleIsOpenComReqDto();
        if (reqDto != null) {
            implementSpecProcessCycleIsOpenComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:984050_1_42957
            implementSpecProcessCycleIsOpenComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984051_1_42957
        }

        /*D3-查周期类型相关配置(公共)[6948]   */
        Assert.isNull(implementSpecProcessCycleIsOpenComReqDto.getTargetCycleContentTypeCode(), "D3-新增标准执行周期阶段(公共)-D3-查周期类型相关配置(公共)-关联目标内容类型编码不能为空", false);
        Assert.isNull(implementSpecProcessCycleIsOpenComReqDto.getEvaluationTemplateId(), "D3-新增标准执行周期阶段(公共)-D3-查周期类型相关配置(公共)-冗余评价模板ID不能为空", false);
        implementSpecProcessCycleIsOpenComRespDto = implementSpecProcessCycleIsOpenCom(implementSpecProcessCycleIsOpenComReqDto)/*vcase invoke 同服务,同domain*/;


        implementSpecProcessCycleIsOpenComRespDto_1 = implementSpecProcessCycleIsOpenComRespDto;
        if ((implementSpecProcessCycleIsOpenComRespDto != null && implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList() != null && implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList().size() > 0)) {
            //if(D3-查周期类型相关配置(公共).模版启用的周期类型列表数据集条数 大于 0)  42943

            AddSubCycleExecuteCycleStageComRespDto addSubCycleExecuteCycleStageComRespDto = null;
            if (implementSpecProcessCycleIsOpenComRespDto != null) {
                AddSubCycleExecuteCycleStageComReqDto addSubCycleExecuteCycleStageComReqDto = new AddSubCycleExecuteCycleStageComReqDto();
                if (implementSpecProcessCycleIsOpenComRespDto != null && implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList() != null && !CollectionUtil.isEmpty(implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList())) {
                    addSubCycleExecuteCycleStageComReqDto.setTemplateOpenCycleTypeList(implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList().stream().map(item -> BeanUtil.toBean(item, TemplateOpenCycleTypeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:984063_1_42944
                }
                if (reqDto != null) {
                    addSubCycleExecuteCycleStageComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:972465_1_42944
                    addSubCycleExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:980886_1_42944
                    addSubCycleExecuteCycleStageComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:980887_1_42944
                    addSubCycleExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:962632_1_42944
                }
                if (implementSpecProcessCycleIsOpenComRespDto != null) {
                    addSubCycleExecuteCycleStageComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:962633_1_42944
                    addSubCycleExecuteCycleStageComReqDto.setSubcycleType(implementSpecProcessCycleIsOpenComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:987351_1_42944
                    addSubCycleExecuteCycleStageComReqDto.setSortCreateTime(implementSpecProcessCycleIsOpenComRespDto.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:977188_1_42944
                    addSubCycleExecuteCycleStageComReqDto.setCycleTypeCode(implementSpecProcessCycleIsOpenComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1816323_1_42944
                }

                /*D3-3新增过程执行周期阶段(公共)[5522]   */
                Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getIsDefinedExecuteCycleStage(), "D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-是否自定义执行周期阶段不能为空", false);
                Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getTargetCycleContentId(), "D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getTargetCycleContentTypeCode(), "D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getTargetId(), "D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-冗余目标ID不能为空", false);
                Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getSubcycleType(), "D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-子周期周期类型不能为空", false);
                Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getEvaluationTemplateId(), "D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getSortCreateTime(), "D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-评价模板创建时间排序不能为空", false);
                addSubCycleExecuteCycleStageComRespDto = targetCycleService.addSubCycleExecuteCycleStageCom(addSubCycleExecuteCycleStageComReqDto)/*vcase invoke isSameApp*/;


            }
            if ((implementSpecProcessCycleIsOpenComRespDto != null && implementSpecProcessCycleIsOpenComRespDto.getTureOrFalse() != null && implementSpecProcessCycleIsOpenComRespDto.getTureOrFalse().equals("TRUE"))) {
                //if(D3-查周期类型相关配置(公共).是否启用双周周期类型 等于 是)  68983

                ImplementDoubleWeekExecuteCycleComRespDto implementDoubleWeekExecuteCycleComRespDto = null;
                if (implementSpecProcessCycleIsOpenComRespDto != null) {
                    ImplementDoubleWeekExecuteCycleComReqDto implementDoubleWeekExecuteCycleComReqDto = new ImplementDoubleWeekExecuteCycleComReqDto();
                    if (implementSpecProcessCycleIsOpenComRespDto != null) {
                        implementDoubleWeekExecuteCycleComReqDto.setCycleTypeCode(implementSpecProcessCycleIsOpenComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1816290_1_68984
                        implementDoubleWeekExecuteCycleComReqDto.setIsLastCycle(implementSpecProcessCycleIsOpenComRespDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1816291_1_68984
                        implementDoubleWeekExecuteCycleComReqDto.setNextCyclePeriod(implementSpecProcessCycleIsOpenComRespDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1816292_1_68984
                        implementDoubleWeekExecuteCycleComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1816296_1_68984
                        implementDoubleWeekExecuteCycleComReqDto.setSortCreateTime(implementSpecProcessCycleIsOpenComRespDto.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1816298_1_68984
                    }
                    if (reqDto != null) {
                        implementDoubleWeekExecuteCycleComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1816297_1_68984
                        implementDoubleWeekExecuteCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1816295_1_68984
                        implementDoubleWeekExecuteCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1816294_1_68984
                        implementDoubleWeekExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1816293_1_68984
                    }

                    /*D3-执行双周执行周期处理(公共)[6985]   */
                    Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getCycleTypeCode(), "D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-双周周期类型标识不能为空", false);
                    Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getIsLastCycle(), "D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-双周是否末级周期不能为空", false);
                    Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getIsDefinedExecuteCycleStage(), "D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-是否自定义执行周期阶段不能为空", false);
                    Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getTargetCycleContentId(), "D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getTargetCycleContentTypeCode(), "D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-关联目标内容类型编码不能为空", false);
                    Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getTargetId(), "D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-冗余目标ID不能为空", false);
                    Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getEvaluationTemplateId(), "D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getSortCreateTime(), "D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-评价模板创建时间排序不能为空", false);
                    implementDoubleWeekExecuteCycleComRespDto = implementDoubleWeekExecuteCycleCom(implementDoubleWeekExecuteCycleComReqDto)/*vcase invoke 同服务,同domain*/;


                }
            }
            if ((reqDto != null && reqDto.getIsDefinedExecuteCycleStage() != null && reqDto.getIsDefinedExecuteCycleStage().equals("TRUE") || implementSpecProcessCycleIsOpenComRespDto != null && implementSpecProcessCycleIsOpenComRespDto.getIsOpenSpecCycleType() != null && implementSpecProcessCycleIsOpenComRespDto.getIsOpenSpecCycleType().equals("TRUE"))) {
                //if((D3-新增标准执行周期阶段(公共).是否自定义执行周期阶段 等于 是 or D3-查周期类型相关配置(公共).是否开启过程特殊周期 等于 是))  42959

                ImplementCompStdExecuteCycleStageComRespDto implementCompStdExecuteCycleStageComRespDto = null;
                if (implementSpecProcessCycleIsOpenComRespDto != null) {
                    ImplementCompStdExecuteCycleStageComReqDto implementCompStdExecuteCycleStageComReqDto = new ImplementCompStdExecuteCycleStageComReqDto();
                    if (implementSpecProcessCycleIsOpenComRespDto != null) {
                        implementCompStdExecuteCycleStageComReqDto.setCycleTypeList(implementSpecProcessCycleIsOpenComRespDto.getCourseCycleTypeList());//list-field-assign//sourceId:981125_1_42961
                        implementCompStdExecuteCycleStageComReqDto.setLastCycleType(implementSpecProcessCycleIsOpenComRespDto.getLastCycleType());//SimpleFieldAssign//sourceId:984074_1_42961
                        implementCompStdExecuteCycleStageComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:967149_1_42961
                    }
                    if (reqDto != null) {
                        implementCompStdExecuteCycleStageComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:981752_1_42961
                        implementCompStdExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:981088_1_42961
                        implementCompStdExecuteCycleStageComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:981089_1_42961
                        implementCompStdExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:967150_1_42961
                    }

                    /*D3-执行补偿新增标准过程执行周期(公共)[6873]   */
                    Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getIsDefinedExecuteCycleStage(), "D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-是否自定义执行周期阶段不能为空", false);
                    Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getTargetCycleContentId(), "D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getTargetCycleContentTypeCode(), "D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-关联目标内容类型编码不能为空", false);
                    Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getTargetId(), "D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-冗余目标ID不能为空", false);
                    Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getEvaluationTemplateId(), "D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-冗余评价模板ID不能为空", false);
                    implementCompStdExecuteCycleStageComRespDto = implementCompStdExecuteCycleStageCom(implementCompStdExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;


                }
            }
        }
//virtualUsage D3-3新增工作周期执行周期阶段(公共)  42313
        AddMetaPhaseExecuteCycleStageComRespDto addMetaPhaseExecuteCycleStageComRespDto = null;
        if (implementSpecProcessCycleIsOpenComRespDto != null) {
            AddMetaPhaseExecuteCycleStageComReqDto addMetaPhaseExecuteCycleStageComReqDto = new AddMetaPhaseExecuteCycleStageComReqDto();
            if (reqDto != null) {
                addMetaPhaseExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:980876_1_42313
                addMetaPhaseExecuteCycleStageComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:980877_1_42313
                addMetaPhaseExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:982217_1_42313
                addMetaPhaseExecuteCycleStageComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:972468_1_42313
            }
            if (implementSpecProcessCycleIsOpenComRespDto != null) {
                addMetaPhaseExecuteCycleStageComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:962636_1_42313
            }

            /*D3-3新增工作周期执行周期阶段(公共)[5518]   */
            Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getTargetCycleContentId(), "D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getTargetCycleContentTypeCode(), "D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-关联目标内容类型编码不能为空", false);
            Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getTargetId(), "D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-冗余目标ID不能为空", false);
            Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getEvaluationTemplateId(), "D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getIsDefinedExecuteCycleStage(), "D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-是否自定义执行周期阶段不能为空", false);
            addMetaPhaseExecuteCycleStageComRespDto = targetCycleService.addMetaPhaseExecuteCycleStageCom(addMetaPhaseExecuteCycleStageComReqDto)/*vcase invoke isSameApp*/;


        }
//virtualUsage D3-3修改当前及下一个执行周期阶段(公共)  42314
        ImplementAnalyzeCompExecuteCycleStageComRespDto implementAnalyzeCompExecuteCycleStageComRespDto = null;
        if (implementSpecProcessCycleIsOpenComRespDto != null) {
            ImplementAnalyzeCompExecuteCycleStageComReqDto implementAnalyzeCompExecuteCycleStageComReqDto = new ImplementAnalyzeCompExecuteCycleStageComReqDto();
            if (implementSpecProcessCycleIsOpenComRespDto != null) {
                implementAnalyzeCompExecuteCycleStageComReqDto.setSubcycleType(implementSpecProcessCycleIsOpenComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:980292_1_42314
            }
            if (reqDto != null) {
                implementAnalyzeCompExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:980291_1_42314
            }

            /*D3-3修改当前及下一个执行周期阶段(公共)[5461]   */
            Assert.isNull(implementAnalyzeCompExecuteCycleStageComReqDto.getSubcycleType(), "D3-新增标准执行周期阶段(公共)-D3-3修改当前及下一个执行周期阶段(公共)-子周期周期类型不能为空", false);
            Assert.isNull(implementAnalyzeCompExecuteCycleStageComReqDto.getEvaluationTemplateId(), "D3-新增标准执行周期阶段(公共)-D3-3修改当前及下一个执行周期阶段(公共)-冗余评价模板ID不能为空", false);
            implementAnalyzeCompExecuteCycleStageComRespDto = targetCycleService.implementAnalyzeCompExecuteCycleStageCom(implementAnalyzeCompExecuteCycleStageComReqDto)/*vcase invoke isSameApp*/;


        }
        if ((implementSpecProcessCycleIsOpenComRespDto != null && implementSpecProcessCycleIsOpenComRespDto.getIsOpenSpecCycleType() != null && implementSpecProcessCycleIsOpenComRespDto.getIsOpenSpecCycleType().equals("TRUE"))) {
            //if(D3-查周期类型相关配置(公共).是否开启过程特殊周期 等于 是)  43063

            RefreshSpecCycleNameComRespDto refreshSpecCycleNameComRespDto = null;
            if (implementSpecProcessCycleIsOpenComRespDto != null) {
                RefreshSpecCycleNameComReqDto refreshSpecCycleNameComReqDto = new RefreshSpecCycleNameComReqDto();
                if (reqDto != null) {
                    refreshSpecCycleNameComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:983581_1_43064
                    refreshSpecCycleNameComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:983582_1_43064
                    refreshSpecCycleNameComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:962648_1_43064
                }
                if (implementSpecProcessCycleIsOpenComRespDto != null) {
                    refreshSpecCycleNameComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:962649_1_43064
                    refreshSpecCycleNameComReqDto.setCustomField(implementSpecProcessCycleIsOpenComRespDto.getTempOpenSpecialCycleType());//SimpleFieldAssign//sourceId:984077_1_43064
                }

                /*D3-更新特殊周期周期名称(公共)[4989]   */
                Assert.isNull(refreshSpecCycleNameComReqDto.getTargetCycleContentId(), "D3-新增标准执行周期阶段(公共)-D3-更新特殊周期周期名称(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(refreshSpecCycleNameComReqDto.getTargetCycleContentTypeCode(), "D3-新增标准执行周期阶段(公共)-D3-更新特殊周期周期名称(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(refreshSpecCycleNameComReqDto.getTargetId(), "D3-新增标准执行周期阶段(公共)-D3-更新特殊周期周期名称(公共)-冗余目标ID不能为空", false);
                Assert.isNull(refreshSpecCycleNameComReqDto.getEvaluationTemplateId(), "D3-新增标准执行周期阶段(公共)-D3-更新特殊周期周期名称(公共)-冗余评价模板ID不能为空", false);
                refreshSpecCycleNameComRespDto = targetCycleService.refreshSpecCycleNameCom(refreshSpecCycleNameComReqDto)/*vcase invoke isSameApp*/;


            }
        }
        AddStandardExecuteCycleStageComComRespDto retData = new AddStandardExecuteCycleStageComComRespDto();
        if (implementSpecProcessCycleIsOpenComRespDto_1 != null) {
            retData.setPeriodicModeTypeCode(implementSpecProcessCycleIsOpenComRespDto_1.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1655002_1
            retData.setSubcycleType(implementSpecProcessCycleIsOpenComRespDto_1.getSubcycleType());//SimpleFieldAssign//sourceId:1922991_1
            retData.setLastCycleType(implementSpecProcessCycleIsOpenComRespDto_1.getLastCycleType());//SimpleFieldAssign//sourceId:1654654_1
            retData.setSecondLastCycleType(implementSpecProcessCycleIsOpenComRespDto_1.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1655003_1
        }


        return retData;
    }

    /**
     * D3-执行补偿新增标准过程执行周期(公共)[6873]
     * gen by moon at 6/3/2024, 4:38:00 PM
     */
    @Trace(operationName = "D3-执行补偿新增标准过程执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCompStdExecuteCycleStageComRespDto implementCompStdExecuteCycleStageCom(ImplementCompStdExecuteCycleStageComReqDto reqDto) {


        //virtualUsage D3-3-查目标周期列表（用于发牌）  42357
        QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto = null;
        QueryEvaObjTargetCycleListComReqDto queryEvaObjTargetCycleListComReqDto = new QueryEvaObjTargetCycleListComReqDto();
        queryEvaObjTargetCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:964498_1_42357
        queryEvaObjTargetCycleListComReqDto.setEvaObjTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:964499_1_42357
        queryEvaObjTargetCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:964500_1_42357
        queryEvaObjTargetCycleListComReqDto.setTreeTypeCode("PLAN_TREE");//sourceId:964501_1_42357
        queryEvaObjTargetCycleListComReqDto.setIsSubCycle("TRUE");//sourceId:964504_1_42357
        queryEvaObjTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:964505_1_42357
        if (reqDto != null) {
            queryEvaObjTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:964503_1_42357
            queryEvaObjTargetCycleListComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:964502_1_42357
        }

        /*D3-3-查目标周期列表（用于发牌）[3451]   */
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjEntityId(), "D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentId(), "D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-关联目标内容类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsSubCycle(), "D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-是否子周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsArchive(), "D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-是否存档不能为空", false);
        queryEvaObjTargetCycleListComRespDto = targetCycleService.queryEvaObjTargetCycleListCom(queryEvaObjTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


        if ((queryEvaObjTargetCycleListComRespDto != null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() != null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().size() > 0)) {
            //if(D3-3-查目标周期列表（用于发牌）.被评对象目标周期列表数据集条数 大于 0)  42358

//ModelCode: circulationCollections
            for (EvaObjTargetCycleDto circulationCollectionsRes : queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList()) {

//ModelCode: circulationCollections
                for (String circulationCollectionsRes_2 : reqDto.getCycleTypeList()) {

                    JudgeCycleTypeIsPlatformComRespDto judgeCycleTypeIsPlatformComRespDto = null;
                    JudgeCycleTypeIsPlatformComReqDto judgeCycleTypeIsPlatformComReqDto = new JudgeCycleTypeIsPlatformComReqDto();
                    if (circulationCollectionsRes_2 != null) {
                        judgeCycleTypeIsPlatformComReqDto.setEndValue(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:966106_1_42989
                    }

                    /*D3判断周期类型是否平台(公共)[4972]   */
                    Assert.isNull(judgeCycleTypeIsPlatformComReqDto.getEndValue(), "D3-执行补偿新增标准过程执行周期(公共)-D3判断周期类型是否平台(公共)-周期类型值不能为空", false);
                    judgeCycleTypeIsPlatformComRespDto = targetCycleService.judgeCycleTypeIsPlatformCom(judgeCycleTypeIsPlatformComReqDto)/*vcase invoke isSameApp*/;


                    ImplementFindExecuteCycleByActualWorkTimeComRespDto implementFindExecuteCycleByActualWorkTimeComRespDto = null;
                    if (judgeCycleTypeIsPlatformComRespDto != null) {
                        ImplementFindExecuteCycleByActualWorkTimeComReqDto implementFindExecuteCycleByActualWorkTimeComReqDto = new ImplementFindExecuteCycleByActualWorkTimeComReqDto();
                        if (circulationCollectionsRes != null) {
                            implementFindExecuteCycleByActualWorkTimeComReqDto.setTargetActualStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:966054_1_42990
                        }
                        if (circulationCollectionsRes_2 != null) {
                            implementFindExecuteCycleByActualWorkTimeComReqDto.setCycleTypeCode(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:966051_1_42990
                        }
                        if (judgeCycleTypeIsPlatformComRespDto != null) {
                            implementFindExecuteCycleByActualWorkTimeComReqDto.setPlatformData(judgeCycleTypeIsPlatformComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:966052_1_42990
                            implementFindExecuteCycleByActualWorkTimeComReqDto.setSpaceId(judgeCycleTypeIsPlatformComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:966053_1_42990
                        }

                        /*D3-根据目标周期实际开始结束时间找周期(公共)[6885]   */

                        implementFindExecuteCycleByActualWorkTimeComRespDto = implementFindExecuteCycleByActualWorkTimeCom(implementFindExecuteCycleByActualWorkTimeComReqDto)/*vcase invoke 同服务,同domain*/;


                    }
                    if ((implementFindExecuteCycleByActualWorkTimeComRespDto != null && implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleId() != null && !(circulationCollectionsRes_2 != null && circulationCollectionsRes_2 != null && circulationCollectionsRes_2.equals("DOUBLE_WEEKS")))) {
                        //if((D3-用目标周期实际开始时间找子周期头部周期ID.周期ID 值不等于空  and M3-过程周期类型发牌【循环开始】（子周期实际开始时间）.答案值 不等于 双周))  42991

                        ImplementTargetContentNextCyclePeriodComRespDto implementTargetContentNextCyclePeriodComRespDto = null;
                        ImplementTargetContentNextCyclePeriodComReqDto implementTargetContentNextCyclePeriodComReqDto = new ImplementTargetContentNextCyclePeriodComReqDto();
                        if (circulationCollectionsRes_2 != null) {
                            implementTargetContentNextCyclePeriodComReqDto.setCycleTypeCode(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:984665_1_43122
                        }
                        if (reqDto != null) {
                            implementTargetContentNextCyclePeriodComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:984663_1_43122
                            implementTargetContentNextCyclePeriodComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984664_1_43122
                        }

                        /*D3-查询目标内容可循环周期类型(公共)[6954]   */
                        Assert.isNull(implementTargetContentNextCyclePeriodComReqDto.getCycleTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-周期类型标识不能为空", false);
                        Assert.isNull(implementTargetContentNextCyclePeriodComReqDto.getTargetCycleContentTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-关联目标内容类型编码不能为空", false);
                        Assert.isNull(implementTargetContentNextCyclePeriodComReqDto.getEvaluationTemplateId(), "D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-冗余评价模板ID不能为空", false);
                        implementTargetContentNextCyclePeriodComRespDto = implementTargetContentNextCyclePeriodCom(implementTargetContentNextCyclePeriodComReqDto)/*vcase invoke 同服务,同domain*/;


                        ImplementAnalysisIsLastCycleTypeComRespDto implementAnalysisIsLastCycleTypeComRespDto = null;
                        ImplementAnalysisIsLastCycleTypeComReqDto implementAnalysisIsLastCycleTypeComReqDto = new ImplementAnalysisIsLastCycleTypeComReqDto();
                        if (reqDto != null) {
                            implementAnalysisIsLastCycleTypeComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:967134_1_42994
                        }
                        if (circulationCollectionsRes_2 != null) {
                            implementAnalysisIsLastCycleTypeComReqDto.setCycleTypeCode(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:967135_1_42994
                        }

                        /*D3-分析当前周期类型是否末级周期类型(公共)[6887]   */
                        Assert.isNull(implementAnalysisIsLastCycleTypeComReqDto.getCycleTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-D3-分析当前周期类型是否末级周期类型(公共)-周期类型标识不能为空", false);
                        implementAnalysisIsLastCycleTypeComRespDto = implementAnalysisIsLastCycleTypeCom(implementAnalysisIsLastCycleTypeComReqDto)/*vcase invoke 同服务,同domain*/;


                        GenerateOrderNumberComRespDto generateOrderNumberComRespDto = null;
                        if (implementFindExecuteCycleByActualWorkTimeComRespDto != null) {
                            GenerateOrderNumberComReqDto generateOrderNumberComReqDto = new GenerateOrderNumberComReqDto();
                            if (circulationCollectionsRes != null) {
                                generateOrderNumberComReqDto.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:982092_1_43030
                            }
                            if (implementFindExecuteCycleByActualWorkTimeComRespDto != null) {
                                generateOrderNumberComReqDto.setCycleEndTime(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:982093_1_43030
                            }

                            /*D3生成周期排序服务(公共)[3545]   */
                            Assert.isNull(generateOrderNumberComReqDto.getCycleStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期开始时间不能为空", false);
                            Assert.isNull(generateOrderNumberComReqDto.getCycleEndTime(), "D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期结束时间不能为空", false);
                            generateOrderNumberComRespDto = cycleTypeService.generateOrderNumberCom(generateOrderNumberComReqDto)/*vcase invoke isSameApp*/;


                        }
                        String string = null;
                        if (implementFindExecuteCycleByActualWorkTimeComRespDto != null && implementTargetContentNextCyclePeriodComRespDto != null && implementAnalysisIsLastCycleTypeComRespDto != null && generateOrderNumberComRespDto != null) {
                            OmsExecuteCycleStage omsExecuteCycleStage = new OmsExecuteCycleStage();
                            omsExecuteCycleStage.setIsFatherCycle("FALSE");//sourceId:966117_1_42995
                            omsExecuteCycleStage.setIsSubCycle("FALSE");//sourceId:966118_1_42995
                            omsExecuteCycleStage.setIsMetaphase("FALSE");//sourceId:966119_1_42995
                            omsExecuteCycleStage.setIsProcessCycleStage("TRUE");//sourceId:966120_1_42995
                            omsExecuteCycleStage.setIsStartCycle("FALSE");//sourceId:966125_1_42995
                            omsExecuteCycleStage.setIsEndCycle("FALSE");//sourceId:966126_1_42995
                            omsExecuteCycleStage.setIsCurrentCycle("FALSE");//sourceId:966140_1_42995
                            omsExecuteCycleStage.setIsNextCycle("FALSE");//sourceId:966141_1_42995
                            if (circulationCollectionsRes != null) {
                                omsExecuteCycleStage.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:966142_1_42995
                                omsExecuteCycleStage.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:966136_1_42995
                                omsExecuteCycleStage.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:966130_1_42995
                                omsExecuteCycleStage.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:991117_1_42995
                                omsExecuteCycleStage.setEvaTempCreateTime(circulationCollectionsRes.getSortCreateTime());//SimpleFieldAssign//sourceId:966115_1_42995
                            }
                            if (implementFindExecuteCycleByActualWorkTimeComRespDto != null) {
                                omsExecuteCycleStage.setCycleId(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleId());//SimpleFieldAssign//sourceId:966114_1_42995
                                omsExecuteCycleStage.setCycleStandardName(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleStandardName());//SimpleFieldAssign//sourceId:966135_1_42995
                                omsExecuteCycleStage.setCycleEndTime(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:966137_1_42995
                                omsExecuteCycleStage.setFillEndtTime(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:966131_1_42995
                                omsExecuteCycleStage.setEvaluateEndtTime(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:991118_1_42995
                                omsExecuteCycleStage.setCycleTypeCode(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:966138_1_42995
                                omsExecuteCycleStage.setCycleTypeInstanceCode(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1605080_1_42995
                            }
                            if (implementTargetContentNextCyclePeriodComRespDto != null) {
                                omsExecuteCycleStage.setNextCyclePeriod(implementTargetContentNextCyclePeriodComRespDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:967576_1_42995
                            }
                            if (implementAnalysisIsLastCycleTypeComRespDto != null) {
                                omsExecuteCycleStage.setIsLastCycle(implementAnalysisIsLastCycleTypeComRespDto.getTureOrFalse());//SimpleFieldAssign//sourceId:966127_1_42995
                            }
                            if (generateOrderNumberComRespDto != null) {
                                omsExecuteCycleStage.setOrderNumber(generateOrderNumberComRespDto.getOrderNumber());//SimpleFieldAssign//sourceId:966116_1_42995
                            }
                            if (reqDto != null) {
                                omsExecuteCycleStage.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:966121_1_42995
                                omsExecuteCycleStage.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:966123_1_42995
                                omsExecuteCycleStage.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:966122_1_42995
                                omsExecuteCycleStage.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:966129_1_42995
                                omsExecuteCycleStage.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:966124_1_42995
                            }

                            /*3-3-07新增执行周期阶段[2354]   */
                            Assert.isNull(omsExecuteCycleStage.getEvaObjTargetCycleId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getCycleId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getCycleStandardName(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getCycleStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getCycleEndTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getFillStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getFillEndtTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getCycleTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getIsLastCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getOrderNumber(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期排序不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getIsFatherCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getIsSubCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getIsMetaphase(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getIsProcessCycleStage(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getIsDefinedExecuteCycleStage(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getRelateContentId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getRelateContentTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getTargetId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getEvaluationTemplateId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getIsStartCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否开始子周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getIsEndCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否截止子周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage.getEvaTempCreateTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空", false);
                            string = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    } else if ((implementFindExecuteCycleByActualWorkTimeComRespDto != null && implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleId() != null && circulationCollectionsRes_2 != null && circulationCollectionsRes_2 != null && circulationCollectionsRes_2.equals("DOUBLE_WEEKS"))) {
                        //elseif((D3-用目标周期实际开始时间找子周期头部周期ID.周期ID 值不等于空  and M3-过程周期类型发牌【循环开始】（子周期实际开始时间）.答案值 等于 双周))  43056

                        OmsExecuteCycleStage omsExecuteCycleStage_1 = null;
                        QueryExecuteCycleLessStartBigEqualEndDetailReq queryExecuteCycleLessStartBigEqualEndDetailReq = new QueryExecuteCycleLessStartBigEqualEndDetailReq();
                        queryExecuteCycleLessStartBigEqualEndDetailReq.setIsProcessCycleStage("TRUE");//sourceId:1816386_1_68995
                        queryExecuteCycleLessStartBigEqualEndDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1816389_1_68995
                        if (circulationCollectionsRes != null) {
                            queryExecuteCycleLessStartBigEqualEndDetailReq.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816383_1_68995
                            queryExecuteCycleLessStartBigEqualEndDetailReq.setCycleEndTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816384_1_68995
                        }
                        if (circulationCollectionsRes_2 != null) {
                            queryExecuteCycleLessStartBigEqualEndDetailReq.setCycleTypeCode(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:1816385_1_68995
                        }
                        if (reqDto != null) {
                            queryExecuteCycleLessStartBigEqualEndDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1816387_1_68995
                            queryExecuteCycleLessStartBigEqualEndDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1816388_1_68995
                        }

                        /*3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）[9657]   */
                        Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getCycleStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-周期开始时间不能为空", false);
                        Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getCycleEndTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-周期结束时间不能为空", false);
                        Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getCycleTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-周期类型标识不能为空", false);
                        Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getIsProcessCycleStage(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-是否过程周期阶段不能为空", false);
                        Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getRelateContentId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-关联目标内容ID不能为空", false);
                        Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getEvaluationTemplateId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-评价模板ID不能为空", false);
                        Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getSubjectLifeCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-主体生命周期不能为空", false);
                        omsExecuteCycleStage_1 = mOmsExecuteCycleStageService.queryExecuteCycleLessStartBigEqualEndDetail(queryExecuteCycleLessStartBigEqualEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;
                        Assert.isTrue(omsExecuteCycleStage_1 == null || omsExecuteCycleStage_1.getExecuteCycleStageId() == null, "找不到数据，系统异常", false);


                        GenerateOrderNumberComRespDto generateOrderNumberComRespDto_2 = null;
                        if (omsExecuteCycleStage_1 != null) {
                            GenerateOrderNumberComReqDto generateOrderNumberComReqDto_1 = new GenerateOrderNumberComReqDto();
                            if (circulationCollectionsRes != null) {
                                generateOrderNumberComReqDto_1.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:982092_1_69552
                            }
                            if (omsExecuteCycleStage_1 != null) {
                                generateOrderNumberComReqDto_1.setCycleEndTime(omsExecuteCycleStage_1.getCycleEndTime());//SimpleFieldAssign//sourceId:982093_1_69552
                            }

                            /*D3生成周期排序服务(公共)[3545]   */
                            Assert.isNull(generateOrderNumberComReqDto_1.getCycleStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期开始时间不能为空", false);
                            Assert.isNull(generateOrderNumberComReqDto_1.getCycleEndTime(), "D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期结束时间不能为空", false);
                            generateOrderNumberComRespDto_2 = cycleTypeService.generateOrderNumberCom(generateOrderNumberComReqDto_1)/*vcase invoke isSameApp*/;


                        }
                        boolean bOOLEAN;
                        if (omsExecuteCycleStage_1 != null && generateOrderNumberComRespDto_2 != null) {
                            OmsExecuteCycleStage omsExecuteCycleStage_3 = new OmsExecuteCycleStage();
                            if (omsExecuteCycleStage_1 != null) {
                                omsExecuteCycleStage_3.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1816391_1_68996
                            }
                            if (circulationCollectionsRes != null) {
                                omsExecuteCycleStage_3.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816393_1_68996
                                omsExecuteCycleStage_3.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816394_1_68996
                                omsExecuteCycleStage_3.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816395_1_68996
                            }
                            if (generateOrderNumberComRespDto_2 != null) {
                                omsExecuteCycleStage_3.setOrderNumber(generateOrderNumberComRespDto_2.getOrderNumber());//SimpleFieldAssign//sourceId:1846352_1_68996
                            }

                            /*3-3-07修改执行周期阶段[2489]   */
                            Assert.isNull(omsExecuteCycleStage_3.getExecuteCycleStageId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                            bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_3)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    } else if ((implementFindExecuteCycleByActualWorkTimeComRespDto != null && implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleId() == null)) {
                        //elseif(D3-用目标周期实际开始时间找子周期头部周期ID.周期ID 值等于空 )  68987

//processBranchName:继续循环 ,processBranchId:68988
                        continue;
                    }
//ModelCode: circulationEnd
                }

//ModelCode: circulationCollections
                for (String circulationCollectionsRes_4 : reqDto.getCycleTypeList()) {

                    JudgeCycleTypeIsPlatformComRespDto judgeCycleTypeIsPlatformComRespDto_2 = null;
                    JudgeCycleTypeIsPlatformComReqDto judgeCycleTypeIsPlatformComReqDto_1 = new JudgeCycleTypeIsPlatformComReqDto();
                    if (circulationCollectionsRes_4 != null) {
                        judgeCycleTypeIsPlatformComReqDto_1.setEndValue(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:966106_1_42998
                    }

                    /*D3判断周期类型是否平台(公共)[4972]   */
                    Assert.isNull(judgeCycleTypeIsPlatformComReqDto_1.getEndValue(), "D3-执行补偿新增标准过程执行周期(公共)-D3判断周期类型是否平台(公共)-周期类型值不能为空", false);
                    judgeCycleTypeIsPlatformComRespDto_2 = targetCycleService.judgeCycleTypeIsPlatformCom(judgeCycleTypeIsPlatformComReqDto_1)/*vcase invoke isSameApp*/;


                    ImplementFindExecuteCycleByActualWorkTimeComRespDto implementFindExecuteCycleByActualWorkTimeComRespDto_2 = null;
                    if (judgeCycleTypeIsPlatformComRespDto_2 != null) {
                        ImplementFindExecuteCycleByActualWorkTimeComReqDto implementFindExecuteCycleByActualWorkTimeComReqDto_1 = new ImplementFindExecuteCycleByActualWorkTimeComReqDto();
                        if (circulationCollectionsRes != null) {
                            implementFindExecuteCycleByActualWorkTimeComReqDto_1.setTargetActualEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:967143_1_43000
                        }
                        if (circulationCollectionsRes_4 != null) {
                            implementFindExecuteCycleByActualWorkTimeComReqDto_1.setCycleTypeCode(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:966051_1_43000
                        }
                        if (judgeCycleTypeIsPlatformComRespDto_2 != null) {
                            implementFindExecuteCycleByActualWorkTimeComReqDto_1.setPlatformData(judgeCycleTypeIsPlatformComRespDto_2.getPlatformData());//SimpleFieldAssign//sourceId:966052_1_43000
                            implementFindExecuteCycleByActualWorkTimeComReqDto_1.setSpaceId(judgeCycleTypeIsPlatformComRespDto_2.getSpaceId());//SimpleFieldAssign//sourceId:966053_1_43000
                        }

                        /*D3-根据目标周期实际开始结束时间找周期(公共)[6885]   */

                        implementFindExecuteCycleByActualWorkTimeComRespDto_2 = implementFindExecuteCycleByActualWorkTimeCom(implementFindExecuteCycleByActualWorkTimeComReqDto_1)/*vcase invoke 同服务,同domain*/;


                    }
                    if ((implementFindExecuteCycleByActualWorkTimeComRespDto_2 != null && implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleId() != null && !(circulationCollectionsRes_4 != null && circulationCollectionsRes_4 != null && circulationCollectionsRes_4.equals("DOUBLE_WEEKS")))) {
                        //if((D3-用目标周期实际结束时间找子周期尾部周期ID.周期ID 值不等于空  and M3-过程周期类型发牌【循环开始】（子周期实际结束时间）.答案值 不等于 双周))  43001

                        ImplementTargetContentNextCyclePeriodComRespDto implementTargetContentNextCyclePeriodComRespDto_2 = null;
                        ImplementTargetContentNextCyclePeriodComReqDto implementTargetContentNextCyclePeriodComReqDto_1 = new ImplementTargetContentNextCyclePeriodComReqDto();
                        if (circulationCollectionsRes_4 != null) {
                            implementTargetContentNextCyclePeriodComReqDto_1.setCycleTypeCode(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:984665_1_43123
                        }
                        if (reqDto != null) {
                            implementTargetContentNextCyclePeriodComReqDto_1.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:984663_1_43123
                            implementTargetContentNextCyclePeriodComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984664_1_43123
                        }

                        /*D3-查询目标内容可循环周期类型(公共)[6954]   */
                        Assert.isNull(implementTargetContentNextCyclePeriodComReqDto_1.getCycleTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-周期类型标识不能为空", false);
                        Assert.isNull(implementTargetContentNextCyclePeriodComReqDto_1.getTargetCycleContentTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-关联目标内容类型编码不能为空", false);
                        Assert.isNull(implementTargetContentNextCyclePeriodComReqDto_1.getEvaluationTemplateId(), "D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-冗余评价模板ID不能为空", false);
                        implementTargetContentNextCyclePeriodComRespDto_2 = implementTargetContentNextCyclePeriodCom(implementTargetContentNextCyclePeriodComReqDto_1)/*vcase invoke 同服务,同domain*/;


                        ImplementAnalysisIsLastCycleTypeComRespDto implementAnalysisIsLastCycleTypeComRespDto_2 = null;
                        ImplementAnalysisIsLastCycleTypeComReqDto implementAnalysisIsLastCycleTypeComReqDto_1 = new ImplementAnalysisIsLastCycleTypeComReqDto();
                        if (reqDto != null) {
                            implementAnalysisIsLastCycleTypeComReqDto_1.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:967134_1_43004
                        }
                        if (circulationCollectionsRes_4 != null) {
                            implementAnalysisIsLastCycleTypeComReqDto_1.setCycleTypeCode(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:967135_1_43004
                        }

                        /*D3-分析当前周期类型是否末级周期类型(公共)[6887]   */
                        Assert.isNull(implementAnalysisIsLastCycleTypeComReqDto_1.getCycleTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-D3-分析当前周期类型是否末级周期类型(公共)-周期类型标识不能为空", false);
                        implementAnalysisIsLastCycleTypeComRespDto_2 = implementAnalysisIsLastCycleTypeCom(implementAnalysisIsLastCycleTypeComReqDto_1)/*vcase invoke 同服务,同domain*/;


                        GenerateOrderNumberComRespDto generateOrderNumberComRespDto_3 = null;
                        if (implementFindExecuteCycleByActualWorkTimeComRespDto_2 != null) {
                            GenerateOrderNumberComReqDto generateOrderNumberComReqDto_2 = new GenerateOrderNumberComReqDto();
                            if (implementFindExecuteCycleByActualWorkTimeComRespDto_2 != null) {
                                generateOrderNumberComReqDto_2.setCycleStartTime(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStartTime());//SimpleFieldAssign//sourceId:982092_1_43031
                            }
                            if (circulationCollectionsRes != null) {
                                generateOrderNumberComReqDto_2.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:982093_1_43031
                            }

                            /*D3生成周期排序服务(公共)[3545]   */
                            Assert.isNull(generateOrderNumberComReqDto_2.getCycleStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期开始时间不能为空", false);
                            Assert.isNull(generateOrderNumberComReqDto_2.getCycleEndTime(), "D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期结束时间不能为空", false);
                            generateOrderNumberComRespDto_3 = cycleTypeService.generateOrderNumberCom(generateOrderNumberComReqDto_2)/*vcase invoke isSameApp*/;


                        }
                        String string_2 = null;
                        if (implementFindExecuteCycleByActualWorkTimeComRespDto_2 != null && implementTargetContentNextCyclePeriodComRespDto_2 != null && implementAnalysisIsLastCycleTypeComRespDto_2 != null && generateOrderNumberComRespDto_3 != null) {
                            OmsExecuteCycleStage omsExecuteCycleStage_4 = new OmsExecuteCycleStage();
                            omsExecuteCycleStage_4.setIsFatherCycle("FALSE");//sourceId:966117_1_43005
                            omsExecuteCycleStage_4.setIsSubCycle("FALSE");//sourceId:966118_1_43005
                            omsExecuteCycleStage_4.setIsMetaphase("FALSE");//sourceId:966119_1_43005
                            omsExecuteCycleStage_4.setIsProcessCycleStage("TRUE");//sourceId:966120_1_43005
                            omsExecuteCycleStage_4.setIsStartCycle("FALSE");//sourceId:966125_1_43005
                            omsExecuteCycleStage_4.setIsEndCycle("FALSE");//sourceId:966126_1_43005
                            omsExecuteCycleStage_4.setIsCurrentCycle("FALSE");//sourceId:966140_1_43005
                            omsExecuteCycleStage_4.setIsNextCycle("FALSE");//sourceId:966141_1_43005
                            if (circulationCollectionsRes != null) {
                                omsExecuteCycleStage_4.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:966142_1_43005
                                omsExecuteCycleStage_4.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:966137_1_43005
                                omsExecuteCycleStage_4.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:966131_1_43005
                                omsExecuteCycleStage_4.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:991118_1_43005
                                omsExecuteCycleStage_4.setEvaTempCreateTime(circulationCollectionsRes.getSortCreateTime());//SimpleFieldAssign//sourceId:966115_1_43005
                            }
                            if (implementFindExecuteCycleByActualWorkTimeComRespDto_2 != null) {
                                omsExecuteCycleStage_4.setCycleId(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleId());//SimpleFieldAssign//sourceId:966114_1_43005
                                omsExecuteCycleStage_4.setCycleStandardName(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStandardName());//SimpleFieldAssign//sourceId:966135_1_43005
                                omsExecuteCycleStage_4.setCycleStartTime(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStartTime());//SimpleFieldAssign//sourceId:966136_1_43005
                                omsExecuteCycleStage_4.setFillStartTime(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStartTime());//SimpleFieldAssign//sourceId:966130_1_43005
                                omsExecuteCycleStage_4.setEvaluateStartTime(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStartTime());//SimpleFieldAssign//sourceId:991117_1_43005
                                omsExecuteCycleStage_4.setCycleTypeCode(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:966138_1_43005
                                omsExecuteCycleStage_4.setCycleTypeInstanceCode(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1605080_1_43005
                            }
                            if (implementTargetContentNextCyclePeriodComRespDto_2 != null) {
                                omsExecuteCycleStage_4.setNextCyclePeriod(implementTargetContentNextCyclePeriodComRespDto_2.getNextCyclePeriod());//SimpleFieldAssign//sourceId:967576_1_43005
                            }
                            if (implementAnalysisIsLastCycleTypeComRespDto_2 != null) {
                                omsExecuteCycleStage_4.setIsLastCycle(implementAnalysisIsLastCycleTypeComRespDto_2.getTureOrFalse());//SimpleFieldAssign//sourceId:966127_1_43005
                            }
                            if (generateOrderNumberComRespDto_3 != null) {
                                omsExecuteCycleStage_4.setOrderNumber(generateOrderNumberComRespDto_3.getOrderNumber());//SimpleFieldAssign//sourceId:966116_1_43005
                            }
                            if (reqDto != null) {
                                omsExecuteCycleStage_4.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:966121_1_43005
                                omsExecuteCycleStage_4.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:966123_1_43005
                                omsExecuteCycleStage_4.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:966122_1_43005
                                omsExecuteCycleStage_4.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:966129_1_43005
                                omsExecuteCycleStage_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:966124_1_43005
                            }

                            /*3-3-07新增执行周期阶段[2354]   */
                            Assert.isNull(omsExecuteCycleStage_4.getEvaObjTargetCycleId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getCycleId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getCycleStandardName(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getCycleStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getCycleEndTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getFillStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getFillEndtTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getCycleTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getIsLastCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getOrderNumber(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期排序不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getIsFatherCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getIsSubCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getIsMetaphase(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getIsProcessCycleStage(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getIsDefinedExecuteCycleStage(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getRelateContentId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getRelateContentTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getTargetId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getEvaluationTemplateId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getIsStartCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否开始子周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getIsEndCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否截止子周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_4.getEvaTempCreateTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空", false);
                            string_2 = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    } else if ((implementFindExecuteCycleByActualWorkTimeComRespDto_2 != null && implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleId() != null && circulationCollectionsRes_4 != null && circulationCollectionsRes_4 != null && circulationCollectionsRes_4.equals("DOUBLE_WEEKS"))) {
                        //elseif((D3-用目标周期实际结束时间找子周期尾部周期ID.周期ID 值不等于空  and M3-过程周期类型发牌【循环开始】（子周期实际结束时间）.答案值 等于 双周))  43058

                        OmsExecuteCycleStage omsExecuteCycleStage_5 = null;
                        QueryExecuteCycleLessEqualStartBigEndDetailReq queryExecuteCycleLessEqualStartBigEndDetailReq = new QueryExecuteCycleLessEqualStartBigEndDetailReq();
                        queryExecuteCycleLessEqualStartBigEndDetailReq.setIsProcessCycleStage("TRUE");//sourceId:1816433_1_69007
                        queryExecuteCycleLessEqualStartBigEndDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1816436_1_69007
                        if (circulationCollectionsRes != null) {
                            queryExecuteCycleLessEqualStartBigEndDetailReq.setCycleStartTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816430_1_69007
                            queryExecuteCycleLessEqualStartBigEndDetailReq.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816431_1_69007
                        }
                        if (circulationCollectionsRes_4 != null) {
                            queryExecuteCycleLessEqualStartBigEndDetailReq.setCycleTypeCode(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:1816432_1_69007
                        }
                        if (reqDto != null) {
                            queryExecuteCycleLessEqualStartBigEndDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1816434_1_69007
                            queryExecuteCycleLessEqualStartBigEndDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1816435_1_69007
                        }

                        /*3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）[9658]   */
                        Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getCycleStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-周期开始时间不能为空", false);
                        Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getCycleEndTime(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-周期结束时间不能为空", false);
                        Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getCycleTypeCode(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-周期类型标识不能为空", false);
                        Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getIsProcessCycleStage(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-是否过程周期阶段不能为空", false);
                        Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getRelateContentId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-关联目标内容ID不能为空", false);
                        Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getEvaluationTemplateId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-评价模板ID不能为空", false);
                        Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getSubjectLifeCycle(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-主体生命周期不能为空", false);
                        omsExecuteCycleStage_5 = mOmsExecuteCycleStageService.queryExecuteCycleLessEqualStartBigEndDetail(queryExecuteCycleLessEqualStartBigEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;
                        Assert.isTrue(omsExecuteCycleStage_5 == null || omsExecuteCycleStage_5.getExecuteCycleStageId() == null, "找不到数据，系统异常", false);


                        GenerateOrderNumberComRespDto generateOrderNumberComRespDto_4 = null;
                        if (omsExecuteCycleStage_5 != null) {
                            GenerateOrderNumberComReqDto generateOrderNumberComReqDto_3 = new GenerateOrderNumberComReqDto();
                            if (omsExecuteCycleStage_5 != null) {
                                generateOrderNumberComReqDto_3.setCycleStartTime(omsExecuteCycleStage_5.getCycleStartTime());//SimpleFieldAssign//sourceId:982092_1_69553
                            }
                            if (circulationCollectionsRes != null) {
                                generateOrderNumberComReqDto_3.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:982093_1_69553
                            }

                            /*D3生成周期排序服务(公共)[3545]   */
                            Assert.isNull(generateOrderNumberComReqDto_3.getCycleStartTime(), "D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期开始时间不能为空", false);
                            Assert.isNull(generateOrderNumberComReqDto_3.getCycleEndTime(), "D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期结束时间不能为空", false);
                            generateOrderNumberComRespDto_4 = cycleTypeService.generateOrderNumberCom(generateOrderNumberComReqDto_3)/*vcase invoke isSameApp*/;


                        }
                        boolean bOOLEAN_1;
                        if (omsExecuteCycleStage_5 != null && generateOrderNumberComRespDto_4 != null) {
                            OmsExecuteCycleStage omsExecuteCycleStage_7 = new OmsExecuteCycleStage();
                            if (omsExecuteCycleStage_5 != null) {
                                omsExecuteCycleStage_7.setExecuteCycleStageId(omsExecuteCycleStage_5.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1816391_1_69003
                            }
                            if (circulationCollectionsRes != null) {
                                omsExecuteCycleStage_7.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816392_1_69003
                                omsExecuteCycleStage_7.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816396_1_69003
                                omsExecuteCycleStage_7.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816397_1_69003
                            }
                            if (generateOrderNumberComRespDto_4 != null) {
                                omsExecuteCycleStage_7.setOrderNumber(generateOrderNumberComRespDto_4.getOrderNumber());//SimpleFieldAssign//sourceId:1846352_1_69003
                            }

                            /*3-3-07修改执行周期阶段[2489]   */
                            Assert.isNull(omsExecuteCycleStage_7.getExecuteCycleStageId(), "D3-执行补偿新增标准过程执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                            bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_7)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    } else if ((implementFindExecuteCycleByActualWorkTimeComRespDto_2 != null && implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleId() == null)) {
                        //elseif(D3-用目标周期实际结束时间找周期.周期ID 值等于空 )  68998

//processBranchName:继续循环 ,processBranchId:69000
                        continue;
                    }
//ModelCode: circulationEnd
                }

//ModelCode: circulationEnd
            }

        }
        ImplementCompStdExecuteCycleStageComRespDto retData = new ImplementCompStdExecuteCycleStageComRespDto();


        return retData;
    }

    /**
     * D3设置目标内容实际工作起止时间等[6876]
     * gen by moon at 7/6/2024, 11:56:55 PM
     */
    @Trace(operationName = "D3设置目标内容实际工作起止时间等")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public SetTargetContActualWorkTimeEtcRespDto setTargetContActualWorkTimeEtc(SetTargetContActualWorkTimeEtcReqDto reqDto) {


        //virtualUsage D3初始化执行进度(0%)  47365
        ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
        ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto = new ImplementStatisticsUpdateExecuteProgressComReqDto();
        implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:1081526_1_47365
        if (reqDto != null) {
            implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081529_1_47365
            implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081530_1_47365
            implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081532_1_47365
        }

        /*D3初始化执行进度(0%)[7094]   */
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3初始化执行进度(0%)-执行进度值不能为空", false);
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(), "D3设置目标内容实际工作起止时间等-D3初始化执行进度(0%)-归属对象内容ID不能为空", false);
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3初始化执行进度(0%)-用途类型编码不能为空", false);
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3初始化执行进度(0%)-主题内容ID不能为空", false);
        implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D3查目标父周期详请  67549
        QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
        QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
        queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1756403_1_67549
        if (reqDto != null) {
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1756402_1_67549
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756404_1_67549
        }

        /*D3查目标父周期详请[8528]   */
        Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(), "D3设置目标内容实际工作起止时间等-D3查目标父周期详请-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3查目标父周期详请-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(), "D3设置目标内容实际工作起止时间等-D3查目标父周期详请-是否存档不能为空", false);
        queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D3更新执行进度(5%)  67550
        ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_1 = null;
        ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_1 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
        implementStatisticsUpdateExecuteProgressComReqDto_1.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67550
        if (reqDto != null) {
            implementStatisticsUpdateExecuteProgressComReqDto_1.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67550
            implementStatisticsUpdateExecuteProgressComReqDto_1.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67550
            implementStatisticsUpdateExecuteProgressComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67550
        }

        /*D3更新执行进度(5%)[7094]   */
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空", false);
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空", false);
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空", false);
        Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空", false);
        implementStatisticsUpdateExecuteProgressComRespDto_1 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_1)/*vcase invoke isSameApp*/;


        if ((queryEvaObjTargetCyclePlatformDetailComRespDto != null && queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode() != null && queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
            //if(D3查目标内容父周期详请.关联目标内容类型编码 等于 目标)  42967

            SetTargetContActualWorkTimeComRespDto setTargetContActualWorkTimeComRespDto = null;
            SetTargetContActualWorkTimeComReqDto setTargetContActualWorkTimeComReqDto = new SetTargetContActualWorkTimeComReqDto();
            if (reqDto != null && reqDto.getTargetContPlanWorkTimeList() != null && !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())) {
                setTargetContActualWorkTimeComReqDto.setTargetCyclePsetList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetCyclePsetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:964184_1_67520
            }
            if (reqDto != null) {
                setTargetContActualWorkTimeComReqDto.setTargetCycleParentCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:964180_1_67520
                setTargetContActualWorkTimeComReqDto.setTargetCycleMidCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:964181_1_67520
                setTargetContActualWorkTimeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964183_1_67520
            }

            /*D3设置目标内容成果汇报时间(公共)[6868]   */
            Assert.isNull(setTargetContActualWorkTimeComReqDto.getTargetCycleParentCycleId(), "D3设置目标内容实际工作起止时间等-D3设置目标内容成果汇报时间(公共)-目标周期父周期ID不能为空", false);
            Assert.isNull(setTargetContActualWorkTimeComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3设置目标内容成果汇报时间(公共)-冗余评价模板ID不能为空", false);
            setTargetContActualWorkTimeComRespDto = setTargetContActualWorkTimeCom(setTargetContActualWorkTimeComReqDto)/*vcase invoke 同服务,同domain*/;


            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_2 = null;
            ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_2 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
            implementStatisticsUpdateExecuteProgressComReqDto_2.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67551
            if (reqDto != null) {
                implementStatisticsUpdateExecuteProgressComReqDto_2.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67551
                implementStatisticsUpdateExecuteProgressComReqDto_2.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67551
                implementStatisticsUpdateExecuteProgressComReqDto_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67551
            }

            /*D3更新执行进度(20%)[7094]   */
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空", false);
            implementStatisticsUpdateExecuteProgressComRespDto_2 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_2)/*vcase invoke isSameApp*/;


            AddStandardExecuteCycleStageComComRespDto addStandardExecuteCycleStageComComRespDto = null;
            if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                AddStandardExecuteCycleStageComComReqDto addStandardExecuteCycleStageComComReqDto = new AddStandardExecuteCycleStageComComReqDto();
                if (reqDto != null) {
                    addStandardExecuteCycleStageComComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsOpenCustomExecuteCycle());//SimpleFieldAssign//sourceId:1756408_1_42968
                    addStandardExecuteCycleStageComComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:981777_1_42968
                }
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    addStandardExecuteCycleStageComComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:981775_1_42968
                    addStandardExecuteCycleStageComComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:981776_1_42968
                }

                /*D3-新增标准执行周期阶段(公共)[6870]   */
                Assert.isNull(addStandardExecuteCycleStageComComReqDto.getIsDefinedExecuteCycleStage(), "D3设置目标内容实际工作起止时间等-D3-新增标准执行周期阶段(公共)-是否自定义执行周期阶段不能为空", false);
                Assert.isNull(addStandardExecuteCycleStageComComReqDto.getTargetCycleContentId(), "D3设置目标内容实际工作起止时间等-D3-新增标准执行周期阶段(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(addStandardExecuteCycleStageComComReqDto.getTargetCycleContentTypeCode(), "D3设置目标内容实际工作起止时间等-D3-新增标准执行周期阶段(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(addStandardExecuteCycleStageComComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3-新增标准执行周期阶段(公共)-冗余评价模板ID不能为空", false);
                addStandardExecuteCycleStageComComRespDto = addStandardExecuteCycleStageComCom(addStandardExecuteCycleStageComComReqDto)/*vcase invoke 同服务,同domain*/;


            }
            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_3 = null;
            ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_3 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
            implementStatisticsUpdateExecuteProgressComReqDto_3.setExecuteProgressValue(Double.valueOf("30"));//CUSTOM_CONVENTION//sourceId:1081561_1_47367
            if (reqDto != null) {
                implementStatisticsUpdateExecuteProgressComReqDto_3.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081564_1_47367
                implementStatisticsUpdateExecuteProgressComReqDto_3.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081565_1_47367
                implementStatisticsUpdateExecuteProgressComReqDto_3.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081567_1_47367
            }

            /*D3更新执行进度(30%）[7094]   */
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(30%）-执行进度值不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(30%）-归属对象内容ID不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(30%）-用途类型编码不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(30%）-主题内容ID不能为空", false);
            implementStatisticsUpdateExecuteProgressComRespDto_3 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_3)/*vcase invoke isSameApp*/;


            RefreshSpecExecCycleStageComRespDto refreshSpecExecCycleStageComRespDto = null;
            if (addStandardExecuteCycleStageComComRespDto != null && queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                RefreshSpecExecCycleStageComReqDto refreshSpecExecCycleStageComReqDto = new RefreshSpecExecCycleStageComReqDto();
                if (addStandardExecuteCycleStageComComRespDto != null) {
                    refreshSpecExecCycleStageComReqDto.setCycleMode(addStandardExecuteCycleStageComComRespDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1922998_1_43461
                    refreshSpecExecCycleStageComReqDto.setSubcycleType(addStandardExecuteCycleStageComComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:1922999_1_43461
                }
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    refreshSpecExecCycleStageComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:981146_1_43461
                    refreshSpecExecCycleStageComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:981147_1_43461
                    refreshSpecExecCycleStageComReqDto.setTargetId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:981145_1_43461
                }
                if (reqDto != null) {
                    refreshSpecExecCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:981144_1_43461
                }

                /*D3-更新目标内容执行周期时段规则[4983]   */
                Assert.isNull(refreshSpecExecCycleStageComReqDto.getCycleMode(), "D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-周期模式不能为空", false);
                Assert.isNull(refreshSpecExecCycleStageComReqDto.getSubcycleType(), "D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-子周期周期类型不能为空", false);
                Assert.isNull(refreshSpecExecCycleStageComReqDto.getTargetCycleContentId(), "D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-关联目标内容ID不能为空", false);
                Assert.isNull(refreshSpecExecCycleStageComReqDto.getTargetCycleContentTypeCode(), "D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-关联目标内容类型编码不能为空", false);
                Assert.isNull(refreshSpecExecCycleStageComReqDto.getTargetId(), "D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-冗余目标ID不能为空", false);
                Assert.isNull(refreshSpecExecCycleStageComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-冗余评价模板ID不能为空", false);
                refreshSpecExecCycleStageComRespDto = targetCycleService.refreshSpecExecCycleStageCom(refreshSpecExecCycleStageComReqDto)/*vcase invoke isSameApp*/;


            }
            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_4 = null;
            ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_4 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
            implementStatisticsUpdateExecuteProgressComReqDto_4.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_47370
            if (reqDto != null) {
                implementStatisticsUpdateExecuteProgressComReqDto_4.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_47370
                implementStatisticsUpdateExecuteProgressComReqDto_4.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_47370
                implementStatisticsUpdateExecuteProgressComReqDto_4.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_47370
            }

            /*D3更新执行进度(20%)[7094]   */
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空", false);
            implementStatisticsUpdateExecuteProgressComRespDto_4 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_4)/*vcase invoke isSameApp*/;


            if ((refreshSpecExecCycleStageComRespDto != null && refreshSpecExecCycleStageComRespDto.getTimeRulesSetLevel() != null && refreshSpecExecCycleStageComRespDto.getTimeRulesSetLevel().equals("EVA_TEMP_LEVEL") || refreshSpecExecCycleStageComRespDto != null && refreshSpecExecCycleStageComRespDto.getTimeRulesSetLevel() != null && refreshSpecExecCycleStageComRespDto.getTimeRulesSetLevel().equals("CYCLE_TYPE_LEVEL"))) {
                //if((D3-更新目标内容执行周期时段规则.时段规则设置级别 等于 评价模板级 or D3-更新目标内容执行周期时段规则.时段规则设置级别 等于 周期类型级))  43463

                RefreshHolidaysAndFestivalsComRespDto refreshHolidaysAndFestivalsComRespDto = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    RefreshHolidaysAndFestivalsComReqDto refreshHolidaysAndFestivalsComReqDto = new RefreshHolidaysAndFestivalsComReqDto();
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        refreshHolidaysAndFestivalsComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:985636_1_43464
                    }
                    if (reqDto != null) {
                        refreshHolidaysAndFestivalsComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:981143_1_43464
                    }

                    /*D3-补偿处理目标内容自定义执行周期节假日[4929]   */
                    Assert.isNull(refreshHolidaysAndFestivalsComReqDto.getTargetCycleContentId(), "D3设置目标内容实际工作起止时间等-D3-补偿处理目标内容自定义执行周期节假日-关联目标内容ID不能为空", false);
                    Assert.isNull(refreshHolidaysAndFestivalsComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3-补偿处理目标内容自定义执行周期节假日-冗余评价模板ID不能为空", false);
                    refreshHolidaysAndFestivalsComRespDto = targetCycleService.refreshHolidaysAndFestivalsCom(refreshHolidaysAndFestivalsComReqDto)/*vcase invoke isSameApp*/;


                }
                ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_5 = null;
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_5 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                implementStatisticsUpdateExecuteProgressComReqDto_5.setExecuteProgressValue(Double.valueOf("10"));//CUSTOM_CONVENTION//sourceId:1081591_1_49312
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto_5.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081594_1_49312
                    implementStatisticsUpdateExecuteProgressComReqDto_5.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081595_1_49312
                    implementStatisticsUpdateExecuteProgressComReqDto_5.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081597_1_49312
                }

                /*D3更新执行进度(10%)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto_5 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_5)/*vcase invoke isSameApp*/;


            } else {
                //else  67556

                ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_6 = null;
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_6 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                implementStatisticsUpdateExecuteProgressComReqDto_6.setExecuteProgressValue(Double.valueOf("10"));//CUSTOM_CONVENTION//sourceId:1081591_1_67557
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto_6.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081594_1_67557
                    implementStatisticsUpdateExecuteProgressComReqDto_6.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081595_1_67557
                    implementStatisticsUpdateExecuteProgressComReqDto_6.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081597_1_67557
                }

                /*D3更新执行进度(10%)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto_6 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_6)/*vcase invoke isSameApp*/;


            }
            ImplementWhetherPastExecutionPeriodIsLastDisposeComRespDto implementWhetherPastExecutionPeriodIsLastDisposeComRespDto = null;
            if (addStandardExecuteCycleStageComComRespDto != null) {
                ImplementWhetherPastExecutionPeriodIsLastDisposeComReqDto implementWhetherPastExecutionPeriodIsLastDisposeComReqDto = new ImplementWhetherPastExecutionPeriodIsLastDisposeComReqDto();
                if (addStandardExecuteCycleStageComComRespDto != null) {
                    implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.setPeriodicModeTypeCode(addStandardExecuteCycleStageComComRespDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1655007_1_64995
                    implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.setLastCycleType(addStandardExecuteCycleStageComComRespDto.getLastCycleType());//SimpleFieldAssign//sourceId:1655010_1_64995
                    implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.setSecondLastCycleType(addStandardExecuteCycleStageComComRespDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1655008_1_64995
                }
                if (reqDto != null) {
                    implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1655009_1_64995
                }

                /*D3执行过往执行周期是否末级处理(公共)[8774]   */
                Assert.isNull(implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.getPeriodicModeTypeCode(), "D3设置目标内容实际工作起止时间等-D3执行过往执行周期是否末级处理(公共)-周期模式类型编码不能为空", false);
                Assert.isNull(implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.getLastCycleType(), "D3设置目标内容实际工作起止时间等-D3执行过往执行周期是否末级处理(公共)-末级周期类型不能为空", false);
                Assert.isNull(implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3执行过往执行周期是否末级处理(公共)-冗余评价模板ID不能为空", false);
                implementWhetherPastExecutionPeriodIsLastDisposeComRespDto = executeCycleService.implementWhetherPastExecutionPeriodIsLastDisposeCom(implementWhetherPastExecutionPeriodIsLastDisposeComReqDto)/*vcase invoke isSameApp*/;


            }
            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_7 = null;
            ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_7 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
            implementStatisticsUpdateExecuteProgressComReqDto_7.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67552
            if (reqDto != null) {
                implementStatisticsUpdateExecuteProgressComReqDto_7.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67552
                implementStatisticsUpdateExecuteProgressComReqDto_7.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67552
                implementStatisticsUpdateExecuteProgressComReqDto_7.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67552
            }

            /*D3更新执行进度(5%)[7094]   */
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空", false);
            implementStatisticsUpdateExecuteProgressComRespDto_7 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_7)/*vcase invoke isSameApp*/;


            ImplementInitializeUpdateTargetContCurrentCycleComRespDto implementInitializeUpdateTargetContCurrentCycleComRespDto = null;
            if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                ImplementInitializeUpdateTargetContCurrentCycleComReqDto implementInitializeUpdateTargetContCurrentCycleComReqDto = new ImplementInitializeUpdateTargetContCurrentCycleComReqDto();
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetContentName(queryEvaObjTargetCyclePlatformDetailComRespDto.getCyclelAlias());//SimpleFieldAssign//sourceId:1151198_1_67519
                    implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1151211_1_67519
                    implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1151212_1_67519
                    implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1151202_1_67519
                }
                if (reqDto != null) {
                    implementInitializeUpdateTargetContCurrentCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151201_1_67519
                }

                /*D3执行初始化更新目标内容当前及下一周期(公共)[7473]   */
                Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetContentName(), "D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-目标内容名称不能为空", false);
                Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetCycleContentTypeCode(), "D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetCycleContentId(), "D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetId(), "D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-冗余目标ID不能为空", false);
                Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-冗余评价模板ID不能为空", false);
                implementInitializeUpdateTargetContCurrentCycleComRespDto = targetContentService.implementInitializeUpdateTargetContCurrentCycleCom(implementInitializeUpdateTargetContCurrentCycleComReqDto)/*vcase invoke isSameApp*/;


            }
            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_8 = null;
            ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_8 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
            implementStatisticsUpdateExecuteProgressComReqDto_8.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67553


            if (reqDto != null) {
                implementStatisticsUpdateExecuteProgressComReqDto_8.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67553
                implementStatisticsUpdateExecuteProgressComReqDto_8.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67553
                implementStatisticsUpdateExecuteProgressComReqDto_8.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67553
            }
            /*D3更新执行进度(5%)[7094]   */
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_8.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_8.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_8.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_8.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空", false);
            implementStatisticsUpdateExecuteProgressComRespDto_8 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_8)/*vcase invoke isSameApp*/;


            RefreshBizAppServiceContCurrentBstepComRespDto refreshBizAppServiceContCurrentBstepComRespDto = null;
            if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                RefreshBizAppServiceContCurrentBstepComReqDto refreshBizAppServiceContCurrentBstepComReqDto = new RefreshBizAppServiceContCurrentBstepComReqDto();
                refreshBizAppServiceContCurrentBstepComReqDto.setBizSceneCode("ADD_EVA_TEMP");//CUSTOM_CONVENTION//sourceId:980933_1_42975
                refreshBizAppServiceContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:980934_1_42975
                refreshBizAppServiceContCurrentBstepComReqDto.setOrderNumber(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:980932_1_42975
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    refreshBizAppServiceContCurrentBstepComReqDto.setEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:980931_1_42975
                }

                /*D3-更新评价主题当前步骤(第5步)[4593]   */
                Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getBizSceneCode(), "D3设置目标内容实际工作起止时间等-D3-更新评价主题当前步骤(第5步)-业务场景标识不能为空", false);
                Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getEntityId(), "D3设置目标内容实际工作起止时间等-D3-更新评价主题当前步骤(第5步)-步骤内容实例ID不能为空", false);
                Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getStepObj(), "D3设置目标内容实际工作起止时间等-D3-更新评价主题当前步骤(第5步)-步骤使用对象表不能为空", false);
                Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getOrderNumber(), "D3设置目标内容实际工作起止时间等-D3-更新评价主题当前步骤(第5步)-排序不能为空", false);
                refreshBizAppServiceContCurrentBstepComRespDto = offStateService.refreshBizAppServiceContCurrentBstepCom(refreshBizAppServiceContCurrentBstepComReqDto)/*vcase invoke isSameApp*/;


            }
            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_9 = null;
            ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_9 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
            implementStatisticsUpdateExecuteProgressComReqDto_9.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67555
            if (reqDto != null) {
                implementStatisticsUpdateExecuteProgressComReqDto_9.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67555
                implementStatisticsUpdateExecuteProgressComReqDto_9.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67555
                implementStatisticsUpdateExecuteProgressComReqDto_9.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67555
            }

            /*D3更新执行进度(5%)[7094]   */
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_9.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_9.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_9.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_9.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空", false);
            implementStatisticsUpdateExecuteProgressComRespDto_9 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_9)/*vcase invoke isSameApp*/;


            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_10 = null;
            ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_10 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
            implementStatisticsUpdateExecuteProgressComReqDto_10.setIsComplete("TRUE");//sourceId:1081809_1_67554
            if (reqDto != null) {
                implementStatisticsUpdateExecuteProgressComReqDto_10.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081574_1_67554
                implementStatisticsUpdateExecuteProgressComReqDto_10.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081575_1_67554
                implementStatisticsUpdateExecuteProgressComReqDto_10.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081577_1_67554
            }

            /*D3更新执行进度(已完成)[7094]   */
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_10.getIsComplete(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-是否已完成不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_10.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-归属对象内容ID不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_10.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-用途类型编码不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_10.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-主题内容ID不能为空", false);
            implementStatisticsUpdateExecuteProgressComRespDto_10 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_10)/*vcase invoke isSameApp*/;


        } else if ((queryEvaObjTargetCyclePlatformDetailComRespDto != null && queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode() != null && queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY") || queryEvaObjTargetCyclePlatformDetailComRespDto != null && queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode() != null && queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
            //elseif((D3查目标内容父周期详请.关联目标内容类型编码 等于 目标分类 or D3查目标内容父周期详请.关联目标内容类型编码 等于 指标))  42969

            AnalysisOverwriteTargetContCustomReportComRespDto analysisOverwriteTargetContCustomReportComRespDto = null;
            AnalysisOverwriteTargetContCustomReportComReqDto analysisOverwriteTargetContCustomReportComReqDto = new AnalysisOverwriteTargetContCustomReportComReqDto();
            if (reqDto != null && reqDto.getTargetContPlanWorkTimeList() != null && !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())) {
                analysisOverwriteTargetContCustomReportComReqDto.setEvaObjTargetCycleList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1756856_1_67572
            }
            if (reqDto != null) {
                analysisOverwriteTargetContCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756855_1_67572
            }

            /*D3分析回写目标内容自定义汇报(公共)[9452]   */
            Assert.isNull(analysisOverwriteTargetContCustomReportComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3分析回写目标内容自定义汇报(公共)-冗余评价模板ID不能为空", false);
            analysisOverwriteTargetContCustomReportComRespDto = analysisOverwriteTargetContCustomReportCom(analysisOverwriteTargetContCustomReportComReqDto)/*vcase invoke 同服务,同domain*/;


            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_11 = null;
            ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_11 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
            implementStatisticsUpdateExecuteProgressComReqDto_11.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67580
            if (reqDto != null) {
                implementStatisticsUpdateExecuteProgressComReqDto_11.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67580
                implementStatisticsUpdateExecuteProgressComReqDto_11.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67580
                implementStatisticsUpdateExecuteProgressComReqDto_11.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67580
            }

            /*D3更新执行进度(5%)[7094]   */
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_11.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_11.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_11.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_11.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空", false);
            implementStatisticsUpdateExecuteProgressComRespDto_11 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_11)/*vcase invoke isSameApp*/;


            PreparationTargetContExtendInfoComRespDto preparationTargetContExtendInfoComRespDto = null;
            if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                PreparationTargetContExtendInfoComReqDto preparationTargetContExtendInfoComReqDto = new PreparationTargetContExtendInfoComReqDto();
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    preparationTargetContExtendInfoComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1754854_1_67518
                    preparationTargetContExtendInfoComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1754855_1_67518
                }
                if (reqDto != null) {
                    preparationTargetContExtendInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1754856_1_67518
                }

                /*D3查询目标内容是否开启自定义执行周期(公共)[8590]   */
                Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentId(), "D3设置目标内容实际工作起止时间等-D3查询目标内容是否开启自定义执行周期(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentTypeCode(), "D3设置目标内容实际工作起止时间等-D3查询目标内容是否开启自定义执行周期(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(preparationTargetContExtendInfoComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3查询目标内容是否开启自定义执行周期(公共)-冗余评价模板ID不能为空", false);
                preparationTargetContExtendInfoComRespDto = targetCalcService.preparationTargetContExtendInfoCom(preparationTargetContExtendInfoComReqDto)/*vcase invoke isSameApp*/;


            }
            if ((preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE") && preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomReport() != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomReport().equals("TRUE"))) {
                //if((D3查询目标内容是否开启自定义执行周期(公共).是否开启自定义执行周期 等于 是 and D3查询目标内容是否开启自定义执行周期(公共).是否开启自定义汇报 等于 是))  42972

                ImplementOverwriteDelCustomExeCycleComRespDto implementOverwriteDelCustomExeCycleComRespDto = null;
                ImplementOverwriteDelCustomExeCycleComReqDto implementOverwriteDelCustomExeCycleComReqDto = new ImplementOverwriteDelCustomExeCycleComReqDto();
                if (reqDto != null && reqDto.getTargetContPlanWorkTimeList() != null && !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())) {
                    implementOverwriteDelCustomExeCycleComReqDto.setEvaObjTargetCycleList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1755412_1_67522
                }
                if (reqDto != null) {
                    implementOverwriteDelCustomExeCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755411_1_67522
                }

                /*D3执行回删自定义执行周期(公共)[9449]   */
                Assert.isNull(implementOverwriteDelCustomExeCycleComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3执行回删自定义执行周期(公共)-冗余评价模板ID不能为空", false);
                implementOverwriteDelCustomExeCycleComRespDto = implementOverwriteDelCustomExeCycleCom(implementOverwriteDelCustomExeCycleComReqDto)/*vcase invoke 同服务,同domain*/;


                ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_12 = null;
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_12 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                implementStatisticsUpdateExecuteProgressComReqDto_12.setExecuteProgressValue(Double.valueOf("90"));//CUSTOM_CONVENTION//sourceId:1756865_1_67583
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto_12.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1756867_1_67583
                    implementStatisticsUpdateExecuteProgressComReqDto_12.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1756868_1_67583
                    implementStatisticsUpdateExecuteProgressComReqDto_12.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756869_1_67583
                }

                /*D3更新执行进度(90%)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_12.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(90%)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_12.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(90%)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_12.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(90%)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_12.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(90%)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto_12 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_12)/*vcase invoke isSameApp*/;


            } else if ((preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("FALSE") && preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomReport() != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomReport().equals("TRUE"))) {
                //elseif((D3查询目标内容是否开启自定义执行周期(公共).是否开启自定义执行周期 等于 否 and D3查询目标内容是否开启自定义执行周期(公共).是否开启自定义汇报 等于 是))  67521

                ImplementAmendTargetContOpenCustomExecuteCycleComRespDto implementAmendTargetContOpenCustomExecuteCycleComRespDto = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    ImplementAmendTargetContOpenCustomExecuteCycleComReqDto implementAmendTargetContOpenCustomExecuteCycleComReqDto = new ImplementAmendTargetContOpenCustomExecuteCycleComReqDto();
                    implementAmendTargetContOpenCustomExecuteCycleComReqDto.setIsOpenCustomExecuteCycle("TRUE");//sourceId:1756330_1_67545
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        implementAmendTargetContOpenCustomExecuteCycleComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756331_1_67545
                        implementAmendTargetContOpenCustomExecuteCycleComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1756332_1_67545
                    }
                    if (reqDto != null) {
                        implementAmendTargetContOpenCustomExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756333_1_67545
                    }

                    /*D3回写目标内容开启自定义执行周期(公共)[9378]   */
                    Assert.isNull(implementAmendTargetContOpenCustomExecuteCycleComReqDto.getIsOpenCustomExecuteCycle(), "D3设置目标内容实际工作起止时间等-D3回写目标内容开启自定义执行周期(公共)-是否开启自定义执行周期不能为空", false);
                    Assert.isNull(implementAmendTargetContOpenCustomExecuteCycleComReqDto.getTargetCycleContentId(), "D3设置目标内容实际工作起止时间等-D3回写目标内容开启自定义执行周期(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(implementAmendTargetContOpenCustomExecuteCycleComReqDto.getTargetCycleContentTypeCode(), "D3设置目标内容实际工作起止时间等-D3回写目标内容开启自定义执行周期(公共)-关联目标内容类型编码不能为空", false);
                    Assert.isNull(implementAmendTargetContOpenCustomExecuteCycleComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3回写目标内容开启自定义执行周期(公共)-冗余评价模板ID不能为空", false);
                    implementAmendTargetContOpenCustomExecuteCycleComRespDto = indexSystemService.implementAmendTargetContOpenCustomExecuteCycleCom(implementAmendTargetContOpenCustomExecuteCycleComReqDto)/*vcase invoke isSameApp*/;


                }
                ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_13 = null;
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_13 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                implementStatisticsUpdateExecuteProgressComReqDto_13.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67565
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto_13.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67565
                    implementStatisticsUpdateExecuteProgressComReqDto_13.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67565
                    implementStatisticsUpdateExecuteProgressComReqDto_13.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67565
                }

                /*D3更新执行进度(20%)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_13.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_13.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_13.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_13.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto_13 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_13)/*vcase invoke isSameApp*/;


                QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto_2 = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto_1 = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
                    queryEvaObjTargetCyclePlatformDetailComReqDto_1.setIsSubCycle("TRUE");//sourceId:1756943_1_67586
                    queryEvaObjTargetCyclePlatformDetailComReqDto_1.setIsArchive("FALSE");//sourceId:1756944_1_67586
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1756940_1_67586
                        queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1756941_1_67586
                        queryEvaObjTargetCyclePlatformDetailComReqDto_1.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756942_1_67586
                    }
                    if (reqDto != null) {
                        queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756945_1_67586
                    }

                    /*D3查目标内容子周期周期类型标识[8528]   */
                    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaObjEntityId(), "D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-被评对象内容表主键ID不能为空", false);
                    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaObjTypeCode(), "D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-被评对象类型编码不能为空", false);
                    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getTargetCycleContentId(), "D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-关联目标内容ID不能为空", false);
                    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getIsSubCycle(), "D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-是否子周期不能为空", false);
                    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getIsArchive(), "D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-是否存档不能为空", false);
                    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-冗余评价模板ID不能为空", false);
                    queryEvaObjTargetCyclePlatformDetailComRespDto_2 = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto_1)/*vcase invoke isSameApp*/;


                }
                AddTargetConExecuteCycleStageComRespDto addTargetConExecuteCycleStageComRespDto = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null && queryEvaObjTargetCyclePlatformDetailComRespDto_2 != null) {
                    AddTargetConExecuteCycleStageComReqDto addTargetConExecuteCycleStageComReqDto = new AddTargetConExecuteCycleStageComReqDto();
                    addTargetConExecuteCycleStageComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1755416_1_67523
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        addTargetConExecuteCycleStageComReqDto.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1755420_1_67523
                        addTargetConExecuteCycleStageComReqDto.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1755419_1_67523
                        addTargetConExecuteCycleStageComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1755414_1_67523
                        addTargetConExecuteCycleStageComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1755413_1_67523
                        addTargetConExecuteCycleStageComReqDto.setTargetId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1755417_1_67523
                    }
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto_2 != null) {
                        addTargetConExecuteCycleStageComReqDto.setSubcycleType(queryEvaObjTargetCyclePlatformDetailComRespDto_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:1755418_1_67523
                    }
                    if (reqDto != null) {
                        addTargetConExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755415_1_67523
                    }

                    /*D3新增目标内容执行周期阶段(公共)[9387]   */
                    Assert.isNull(addTargetConExecuteCycleStageComReqDto.getEvaObjEntityId(), "D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-被评对象内容表主键ID不能为空", false);
                    Assert.isNull(addTargetConExecuteCycleStageComReqDto.getEvaObjTypeCode(), "D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-被评对象类型编码不能为空", false);
                    Assert.isNull(addTargetConExecuteCycleStageComReqDto.getTargetCycleContentId(), "D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(addTargetConExecuteCycleStageComReqDto.getTargetCycleContentTypeCode(), "D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-关联目标内容类型编码不能为空", false);
                    Assert.isNull(addTargetConExecuteCycleStageComReqDto.getSubcycleType(), "D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-子周期周期类型不能为空", false);
                    Assert.isNull(addTargetConExecuteCycleStageComReqDto.getTargetId(), "D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-冗余目标ID不能为空", false);
                    Assert.isNull(addTargetConExecuteCycleStageComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(addTargetConExecuteCycleStageComReqDto.getSpaceId(), "D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-创建于空间ID不能为空", false);
                    addTargetConExecuteCycleStageComRespDto = addTargetConExecuteCycleStageCom(addTargetConExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;


                }
                ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_14 = null;
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_14 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                implementStatisticsUpdateExecuteProgressComReqDto_14.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67567
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto_14.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67567
                    implementStatisticsUpdateExecuteProgressComReqDto_14.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67567
                    implementStatisticsUpdateExecuteProgressComReqDto_14.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67567
                }

                /*D3更新执行进度(20%)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_14.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_14.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_14.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_14.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto_14 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_14)/*vcase invoke isSameApp*/;


                ImplementOverwriteDelCustomExeCycleComRespDto implementOverwriteDelCustomExeCycleComRespDto_1 = null;
                ImplementOverwriteDelCustomExeCycleComReqDto implementOverwriteDelCustomExeCycleComReqDto_1 = new ImplementOverwriteDelCustomExeCycleComReqDto();
                if (reqDto != null && reqDto.getTargetContPlanWorkTimeList() != null && !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())) {
                    implementOverwriteDelCustomExeCycleComReqDto_1.setEvaObjTargetCycleList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1755412_1_67524
                }
                if (reqDto != null) {
                    implementOverwriteDelCustomExeCycleComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755411_1_67524
                }

                /*D3执行回删自定义执行周期(公共)[9449]   */
                Assert.isNull(implementOverwriteDelCustomExeCycleComReqDto_1.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3执行回删自定义执行周期(公共)-冗余评价模板ID不能为空", false);
                implementOverwriteDelCustomExeCycleComRespDto_1 = implementOverwriteDelCustomExeCycleCom(implementOverwriteDelCustomExeCycleComReqDto_1)/*vcase invoke 同服务,同domain*/;


                ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_15 = null;
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_15 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                implementStatisticsUpdateExecuteProgressComReqDto_15.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67568
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto_15.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67568
                    implementStatisticsUpdateExecuteProgressComReqDto_15.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67568
                    implementStatisticsUpdateExecuteProgressComReqDto_15.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67568
                }

                /*D3更新执行进度(20%)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_15.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_15.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_15.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_15.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto_15 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_15)/*vcase invoke isSameApp*/;


                ImplementOverwriteDelTargetContReportTimerTaskPlanComRespDto implementOverwriteDelTargetContReportTimerTaskPlanComRespDto = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    ImplementOverwriteDelTargetContReportTimerTaskPlanComReqDto implementOverwriteDelTargetContReportTimerTaskPlanComReqDto = new ImplementOverwriteDelTargetContReportTimerTaskPlanComReqDto();
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1756328_1_67544
                        implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1756329_1_67544
                        implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756326_1_67544
                    }
                    if (reqDto != null) {
                        implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756327_1_67544
                    }

                    /*D3回删目标内容汇报任务任务调度(公共)[9451]   */
                    Assert.isNull(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.getEvaObjEntityId(), "D3设置目标内容实际工作起止时间等-D3回删目标内容汇报任务任务调度(公共)-被评对象内容表主键ID不能为空", false);
                    Assert.isNull(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.getEvaObjTypeCode(), "D3设置目标内容实际工作起止时间等-D3回删目标内容汇报任务任务调度(公共)-被评对象类型编码不能为空", false);
                    Assert.isNull(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.getTargetCycleContentId(), "D3设置目标内容实际工作起止时间等-D3回删目标内容汇报任务任务调度(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3回删目标内容汇报任务任务调度(公共)-冗余评价模板ID不能为空", false);
                    implementOverwriteDelTargetContReportTimerTaskPlanComRespDto = implementOverwriteDelTargetContReportTimerTaskPlanCom(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto)/*vcase invoke 同服务,同domain*/;


                }
                ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_16 = null;
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_16 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                implementStatisticsUpdateExecuteProgressComReqDto_16.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67569
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto_16.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67569
                    implementStatisticsUpdateExecuteProgressComReqDto_16.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67569
                    implementStatisticsUpdateExecuteProgressComReqDto_16.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67569
                }

                /*D3更新执行进度(20%)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_16.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_16.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_16.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_16.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto_16 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_16)/*vcase invoke isSameApp*/;


                ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeComRespDto = null;
                ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto implementOverwriteTargetContFatherOrMidReportTimeComReqDto = new ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto();
                if (reqDto != null) {
                    implementOverwriteTargetContFatherOrMidReportTimeComReqDto.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1755947_1_67546
                    implementOverwriteTargetContFatherOrMidReportTimeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755946_1_67546
                }

                /*D3回写目标内容父或中成果汇报时间(公共)[9450]   */
                Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto.getEvaObjTargetCycleId(), "D3设置目标内容实际工作起止时间等-D3回写目标内容父或中成果汇报时间(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3回写目标内容父或中成果汇报时间(公共)-冗余评价模板ID不能为空", false);
                implementOverwriteTargetContFatherOrMidReportTimeComRespDto = implementOverwriteTargetContFatherOrMidReportTimeCom(implementOverwriteTargetContFatherOrMidReportTimeComReqDto)/*vcase invoke 同服务,同domain*/;


                ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_17 = null;
                ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_17 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                implementStatisticsUpdateExecuteProgressComReqDto_17.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67581
                if (reqDto != null) {
                    implementStatisticsUpdateExecuteProgressComReqDto_17.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67581
                    implementStatisticsUpdateExecuteProgressComReqDto_17.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67581
                    implementStatisticsUpdateExecuteProgressComReqDto_17.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67581
                }

                /*D3更新执行进度(5%)[7094]   */
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_17.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_17.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_17.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空", false);
                Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_17.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空", false);
                implementStatisticsUpdateExecuteProgressComRespDto_17 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_17)/*vcase invoke isSameApp*/;


                if ((reqDto != null && reqDto.getTargetCycleMidCycleId() != null)) {
                    //if(D3设置目标内容实际工作起止时间等.目标周期中期ID 值不等于空 )  67547

                    ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeComRespDto_1 = null;
                    ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1 = new ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto();
                    if (reqDto != null) {
                        implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:1755947_1_67548
                        implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755946_1_67548
                    }

                    /*D3回写目标内容父或中成果汇报时间(公共)[9450]   */
                    Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.getEvaObjTargetCycleId(), "D3设置目标内容实际工作起止时间等-D3回写目标内容父或中成果汇报时间(公共)-被评对象目标周期ID不能为空", false);
                    Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.getEvaluationTemplateId(), "D3设置目标内容实际工作起止时间等-D3回写目标内容父或中成果汇报时间(公共)-冗余评价模板ID不能为空", false);
                    implementOverwriteTargetContFatherOrMidReportTimeComRespDto_1 = implementOverwriteTargetContFatherOrMidReportTimeCom(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1)/*vcase invoke 同服务,同domain*/;


                    ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_18 = null;
                    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_18 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                    implementStatisticsUpdateExecuteProgressComReqDto_18.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67577
                    if (reqDto != null) {
                        implementStatisticsUpdateExecuteProgressComReqDto_18.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67577
                        implementStatisticsUpdateExecuteProgressComReqDto_18.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67577
                        implementStatisticsUpdateExecuteProgressComReqDto_18.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67577
                    }

                    /*D3更新执行进度(5%)[7094]   */
                    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_18.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空", false);
                    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_18.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空", false);
                    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_18.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空", false);
                    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_18.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空", false);
                    implementStatisticsUpdateExecuteProgressComRespDto_18 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_18)/*vcase invoke isSameApp*/;


                } else {
                    //else  67576

                    ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_19 = null;
                    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_19 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
                    implementStatisticsUpdateExecuteProgressComReqDto_19.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67578
                    if (reqDto != null) {
                        implementStatisticsUpdateExecuteProgressComReqDto_19.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67578
                        implementStatisticsUpdateExecuteProgressComReqDto_19.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67578
                        implementStatisticsUpdateExecuteProgressComReqDto_19.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67578
                    }

                    /*D3更新执行进度(5%)[7094]   */
                    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_19.getExecuteProgressValue(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空", false);
                    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_19.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空", false);
                    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_19.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空", false);
                    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_19.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空", false);
                    implementStatisticsUpdateExecuteProgressComRespDto_19 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_19)/*vcase invoke isSameApp*/;


                }
            }
            ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_20 = null;
            ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_20 = new ImplementStatisticsUpdateExecuteProgressComReqDto();
            implementStatisticsUpdateExecuteProgressComReqDto_20.setIsComplete("TRUE");//sourceId:1081809_1_67585
            if (reqDto != null) {
                implementStatisticsUpdateExecuteProgressComReqDto_20.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081574_1_67585
                implementStatisticsUpdateExecuteProgressComReqDto_20.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081575_1_67585
                implementStatisticsUpdateExecuteProgressComReqDto_20.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081577_1_67585
            }

            /*D3更新执行进度(已完成)[7094]   */
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_20.getIsComplete(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-是否已完成不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_20.getObjectId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-归属对象内容ID不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_20.getUseTypeCode(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-用途类型编码不能为空", false);
            Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_20.getThemeContentId(), "D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-主题内容ID不能为空", false);
            implementStatisticsUpdateExecuteProgressComRespDto_20 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_20)/*vcase invoke isSameApp*/;


        }
        SetTargetContActualWorkTimeEtcRespDto retData = new SetTargetContActualWorkTimeEtcRespDto();


        return retData;
    }

    /**
     * D3获取上级目标内容实际工作起止时间[6877]
     * gen by moon at 5/25/2023, 12:20:47 AM
     */
    @Trace(operationName = "D3获取上级目标内容实际工作起止时间")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainParentTargetContActualWorkTimeRespDto obtainParentTargetContActualWorkTime(ObtainParentTargetContActualWorkTimeReqDto reqDto) {


        OmsTargetCyclePlanSet omsTargetCyclePlanSet_1 = null;
//virtualUsage 3-3-09查当前目标周期详情  42999
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:964593_1_42999
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964591_1_42999
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964592_1_42999
        }

        /*3-3-09查当前目标周期详情[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3获取上级目标内容实际工作起止时间-3-3-09查当前目标周期详情-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3获取上级目标内容实际工作起止时间-3-3-09查当前目标周期详情-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3获取上级目标内容实际工作起止时间-3-3-09查当前目标周期详情-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsSubCycle() != null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsParentCycle() != null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("FALSE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsMetaphase() != null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE")) || (omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsParentCycle() != null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsSubCycle() != null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsMetaphase() != null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE")) || (omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsParentCycle() != null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsSubCycle() != null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsMetaphase() != null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE"))) {
            //if((3-3-09查当前目标周期详情.是否子周期 等于 是 and 3-3-09查当前目标周期详情.是否父周期 等于 否 and 3-3-09查当前目标周期详情.是否中期 等于 否) or (3-3-09查当前目标周期详情.是否父周期 等于 是 and 3-3-09查当前目标周期详情.是否子周期 等于 是 and 3-3-09查当前目标周期详情.是否中期 等于 是) or (3-3-09查当前目标周期详情.是否父周期 等于 是 and 3-3-09查当前目标周期详情.是否子周期 等于 是 and 3-3-09查当前目标周期详情.是否中期 等于 否))  43006

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            if (omsEvaluationObjectTargetCycle != null) {
                QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
                queryEvaObjTargetCycleDetailReq_1.setIsSubCycle("TRUE");//sourceId:964831_1_43007
                queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:964833_1_43007
                if (omsEvaluationObjectTargetCycle != null) {
                    queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964827_1_43007
                    queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:964828_1_43007
                    queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:964829_1_43007
                    queryEvaObjTargetCycleDetailReq_1.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:964830_1_43007
                }
                if (reqDto != null) {
                    queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964832_1_43007
                }

                /*3-3-09查上级目标子周期[2313]   */
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTargetCycleCode(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-被评对象目标周期标识不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-被评对象类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getCycleId(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-周期ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsSubCycle(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-是否子周期不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-是否存档不能为空", false);
                omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            }
            OmsTargetCyclePlanSet omsTargetCyclePlanSet = null;
            if (omsEvaluationObjectTargetCycle_2 != null) {
                QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq = new QueryTargetCyclePsetDetailReq();
                queryTargetCyclePsetDetailReq.setIsArchive("FALSE");//sourceId:964748_1_43008
                queryTargetCyclePsetDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:964743_1_43008
                if (omsEvaluationObjectTargetCycle_2 != null) {
                    queryTargetCyclePsetDetailReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964741_1_43008
                }
                if (reqDto != null) {
                    queryTargetCyclePsetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964746_1_43008
                }

                /*3-3-08查目标周期规划设置（实际工作开始与结束时间）[3368]   */
                Assert.isNull(queryTargetCyclePsetDetailReq.getEvaObjTargetCycleId(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-归属被评对象目标周期ID不能为空", false);
                Assert.isNull(queryTargetCyclePsetDetailReq.getEvaluationTemplateId(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-冗余评价模板ID不能为空", false);
                Assert.isNull(queryTargetCyclePsetDetailReq.getIsArchive(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-是否存档不能为空", false);
                Assert.isNull(queryTargetCyclePsetDetailReq.getSpaceId(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-创建于空间ID不能为空", false);
                omsTargetCyclePlanSet = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                omsTargetCyclePlanSet_1 = omsTargetCyclePlanSet;
            }
        } else if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsParentCycle() != null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsSubCycle() != null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("FALSE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsMetaphase() != null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE")) || (omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsParentCycle() != null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsMetaphase() != null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsSubCycle() != null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("FALSE"))) {
            //elseif((3-3-09查当前目标周期详情.是否父周期 等于 是 and 3-3-09查当前目标周期详情.是否子周期 等于 否 and 3-3-09查当前目标周期详情.是否中期 等于 否) or (3-3-09查当前目标周期详情.是否父周期 等于 是 and 3-3-09查当前目标周期详情.是否中期 等于 是 and 3-3-09查当前目标周期详情.是否子周期 等于 否))  43009

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_4 = null;
            if (omsEvaluationObjectTargetCycle != null) {
                QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2 = new QueryEvaObjTargetCycleDetailReq();
                queryEvaObjTargetCycleDetailReq_2.setIsArchive("FALSE");//sourceId:964991_1_43011
                if (omsEvaluationObjectTargetCycle != null) {
                    queryEvaObjTargetCycleDetailReq_2.setParentEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964986_1_43011
                    queryEvaObjTargetCycleDetailReq_2.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:964987_1_43011
                    queryEvaObjTargetCycleDetailReq_2.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:964988_1_43011
                    queryEvaObjTargetCycleDetailReq_2.setIsParentCycle(omsEvaluationObjectTargetCycle.getIsParentCycle());//SimpleFieldAssign//sourceId:964989_1_43011
                }
                if (reqDto != null) {
                    queryEvaObjTargetCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964990_1_43011
                }

                /*3-3-09查上级目标周期[2313]   */
                Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getParentEvaObjTargetCycleId(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-上级被评对象目标周期标识不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjEntityId(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTypeCode(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-被评对象类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaluationTemplateId(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsArchive(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-是否存档不能为空", false);
                omsEvaluationObjectTargetCycle_4 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


            }
            OmsTargetCyclePlanSet omsTargetCyclePlanSet_2 = null;
            if (omsEvaluationObjectTargetCycle_4 != null) {
                QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq_1 = new QueryTargetCyclePsetDetailReq();
                queryTargetCyclePsetDetailReq_1.setIsArchive("FALSE");//sourceId:964748_1_43012
                queryTargetCyclePsetDetailReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:964743_1_43012
                if (omsEvaluationObjectTargetCycle_4 != null) {
                    queryTargetCyclePsetDetailReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_4.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964741_1_43012
                }
                if (reqDto != null) {
                    queryTargetCyclePsetDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964746_1_43012
                }

                /*3-3-08查目标周期规划设置（实际工作开始与结束时间）[3368]   */
                Assert.isNull(queryTargetCyclePsetDetailReq_1.getEvaObjTargetCycleId(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-归属被评对象目标周期ID不能为空", false);
                Assert.isNull(queryTargetCyclePsetDetailReq_1.getEvaluationTemplateId(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-冗余评价模板ID不能为空", false);
                Assert.isNull(queryTargetCyclePsetDetailReq_1.getIsArchive(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-是否存档不能为空", false);
                Assert.isNull(queryTargetCyclePsetDetailReq_1.getSpaceId(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-创建于空间ID不能为空", false);
                omsTargetCyclePlanSet_2 = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                omsTargetCyclePlanSet_1 = omsTargetCyclePlanSet_2;
            }
        } else if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsMetaphase() != null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsParentCycle() != null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("FALSE") && omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getIsMetaphase() != null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE"))) {
            //elseif((3-3-09查当前目标周期详情.是否中期 等于 是 and 3-3-09查当前目标周期详情.是否父周期 等于 否 and 3-3-09查当前目标周期详情.是否中期 等于 否))  43010

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_6 = null;
            if (omsEvaluationObjectTargetCycle != null) {
                QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_3 = new QueryEvaObjTargetCycleDetailReq();
                queryEvaObjTargetCycleDetailReq_3.setIsArchive("FALSE");//sourceId:964991_1_43015
                if (omsEvaluationObjectTargetCycle != null) {
                    queryEvaObjTargetCycleDetailReq_3.setParentEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964986_1_43015
                    queryEvaObjTargetCycleDetailReq_3.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:964987_1_43015
                    queryEvaObjTargetCycleDetailReq_3.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:964988_1_43015
                    queryEvaObjTargetCycleDetailReq_3.setIsMetaphase(omsEvaluationObjectTargetCycle.getIsMetaphase());//SimpleFieldAssign//sourceId:981148_1_43015
                }
                if (reqDto != null) {
                    queryEvaObjTargetCycleDetailReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964990_1_43015
                }

                /*3-3-09查上级目标周期[2313]   */
                Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getParentEvaObjTargetCycleId(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-上级被评对象目标周期标识不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getEvaObjEntityId(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getEvaObjTypeCode(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-被评对象类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getEvaluationTemplateId(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getIsArchive(), "D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-是否存档不能为空", false);
                omsEvaluationObjectTargetCycle_6 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;


            }
            OmsTargetCyclePlanSet omsTargetCyclePlanSet_3 = null;
            if (omsEvaluationObjectTargetCycle_6 != null) {
                QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq_2 = new QueryTargetCyclePsetDetailReq();
                queryTargetCyclePsetDetailReq_2.setIsArchive("FALSE");//sourceId:964748_1_43013
                queryTargetCyclePsetDetailReq_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:964743_1_43013
                if (omsEvaluationObjectTargetCycle_6 != null) {
                    queryTargetCyclePsetDetailReq_2.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_6.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964741_1_43013
                }
                if (reqDto != null) {
                    queryTargetCyclePsetDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964746_1_43013
                }

                /*3-3-08查目标周期规划设置（实际工作开始与结束时间）[3368]   */
                Assert.isNull(queryTargetCyclePsetDetailReq_2.getEvaObjTargetCycleId(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-归属被评对象目标周期ID不能为空", false);
                Assert.isNull(queryTargetCyclePsetDetailReq_2.getEvaluationTemplateId(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-冗余评价模板ID不能为空", false);
                Assert.isNull(queryTargetCyclePsetDetailReq_2.getIsArchive(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-是否存档不能为空", false);
                Assert.isNull(queryTargetCyclePsetDetailReq_2.getSpaceId(), "D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-创建于空间ID不能为空", false);
                omsTargetCyclePlanSet_3 = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


                omsTargetCyclePlanSet_1 = omsTargetCyclePlanSet_3;
            }
        }
        ObtainParentTargetContActualWorkTimeRespDto retData = new ObtainParentTargetContActualWorkTimeRespDto();
        if (omsTargetCyclePlanSet_1 != null) {
            retData.setTargetCyclePlanSetId(omsTargetCyclePlanSet_1.getTargetCyclePlanSetId());//SimpleFieldAssign//sourceId:965084_1
            retData.setTargetActualStartTime(omsTargetCyclePlanSet_1.getTargetActualStartTime());//SimpleFieldAssign//sourceId:965085_1
            retData.setTargetActualEndtTime(omsTargetCyclePlanSet_1.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:965086_1
        }


        return retData;
    }

    /**
     * D3-分析时段规则设置(公共)[6879]
     * gen by moon at 5/21/2023, 7:04:24 AM
     */
    @Trace(operationName = "D3-分析时段规则设置(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTimeRulesSetLevelComRespDto implementTimeRulesSetLevelCom(ImplementTimeRulesSetLevelComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage D2-3查时段规则设置规则配置  42368
        QueryConfItemMatchEvaTempAnswerDetailComRespDto queryConfItemMatchEvaTempAnswerDetailComRespDto = null;
        QueryConfItemMatchEvaTempAnswerDetailComReqDto queryConfItemMatchEvaTempAnswerDetailComReqDto = new QueryConfItemMatchEvaTempAnswerDetailComReqDto();
        queryConfItemMatchEvaTempAnswerDetailComReqDto.setConfItemCode("TIME_RULES_SET_LEVEL");//CUSTOM_CONVENTION//sourceId:964835_1_42368
        queryConfItemMatchEvaTempAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:964872_1_42368
        queryConfItemMatchEvaTempAnswerDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:964873_1_42368
        if (reqDto != null) {
            queryConfItemMatchEvaTempAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964836_1_42368
        }

        /*D2-3查时段规则设置规则配置[3067]   */
        Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto.getResultAspObjId(), "D3-分析时段规则设置(公共)-D2-3查时段规则设置规则配置-评价模板ID不能为空", false);
        Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto.getConfItemCode(), "D3-分析时段规则设置(公共)-D2-3查时段规则设置规则配置-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto.getIsPlatData(), "D3-分析时段规则设置(公共)-D2-3查时段规则设置规则配置-是否标准答案不能为空", false);
        Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto.getSubjectLifeCycle(), "D3-分析时段规则设置(公共)-D2-3查时段规则设置规则配置-主体生命周期不能为空", false);
        queryConfItemMatchEvaTempAnswerDetailComRespDto = confSchemeService.queryConfItemMatchEvaTempAnswerDetailCom(queryConfItemMatchEvaTempAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((queryConfItemMatchEvaTempAnswerDetailComRespDto != null && queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel() != null && queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel().equals("EVA_TEMP_LEVEL"))) {
            //if(D2-3查时段规则设置规则配置.时段规则设置级别 等于 评价模板级)  42371

            QueryConfItemMatchEvaTempAnswerDetailComRespDto queryConfItemMatchEvaTempAnswerDetailComRespDto_2 = null;
            QueryConfItemMatchEvaTempAnswerDetailComReqDto queryConfItemMatchEvaTempAnswerDetailComReqDto_1 = new QueryConfItemMatchEvaTempAnswerDetailComReqDto();
            queryConfItemMatchEvaTempAnswerDetailComReqDto_1.setConfItemCode("FILL_TIME_RULES_CODE");//CUSTOM_CONVENTION//sourceId:965015_1_42379
            queryConfItemMatchEvaTempAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:965052_1_42379
            queryConfItemMatchEvaTempAnswerDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:965053_1_42379
            if (reqDto != null) {
                queryConfItemMatchEvaTempAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:965016_1_42379
            }

            /*D2-3查模板填报时段规则标识[3067]   */
            Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto_1.getResultAspObjId(), "D3-分析时段规则设置(公共)-D2-3查模板填报时段规则标识-评价模板ID不能为空", false);
            Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto_1.getConfItemCode(), "D3-分析时段规则设置(公共)-D2-3查模板填报时段规则标识-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto_1.getIsPlatData(), "D3-分析时段规则设置(公共)-D2-3查模板填报时段规则标识-是否标准答案不能为空", false);
            Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto_1.getSubjectLifeCycle(), "D3-分析时段规则设置(公共)-D2-3查模板填报时段规则标识-主体生命周期不能为空", false);
            queryConfItemMatchEvaTempAnswerDetailComRespDto_2 = confSchemeService.queryConfItemMatchEvaTempAnswerDetailCom(queryConfItemMatchEvaTempAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            if (queryConfItemMatchEvaTempAnswerDetailComRespDto_2 != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
                if (queryConfItemMatchEvaTempAnswerDetailComRespDto_2 != null) {
                    receptionServiceReq.setCycleConfCode(queryConfItemMatchEvaTempAnswerDetailComRespDto_2.getFillTimeRulesCode());//SimpleFieldAssign//sourceId:965535_1_42386
                }

                /*约定出参：周期配置标识[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getCycleConfCode(), "D3-分析时段规则设置(公共)-约定出参：周期配置标识-周期配置标识不能为空", false);
                receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((queryConfItemMatchEvaTempAnswerDetailComRespDto != null && queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel() != null && queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel().equals("CYCLE_TYPE_LEVEL"))) {
            //elseif(D2-3查时段规则设置规则配置.时段规则设置级别 等于 周期类型级)  42373

            OmsEvaCycleConf omsEvaCycleConf = null;
            QueryCycleConfDetailReq queryCycleConfDetailReq = new QueryCycleConfDetailReq();
            queryCycleConfDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:964994_1_42380
            if (reqDto != null) {
                queryCycleConfDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:964993_1_42380
            }

            /*3-2-08查周期配置详情[2360]   */
            Assert.isNull(queryCycleConfDetailReq.getCycleTypeCode(), "D3-分析时段规则设置(公共)-3-2-08查周期配置详情-周期类型标识不能为空", false);
            Assert.isNull(queryCycleConfDetailReq.getSubjectLifeCycle(), "D3-分析时段规则设置(公共)-3-2-08查周期配置详情-主体生命周期不能为空", false);
            omsEvaCycleConf = mOmsEvaCycleConfService.queryCycleConfDetail(queryCycleConfDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            if (omsEvaCycleConf != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                if (omsEvaCycleConf != null) {
                    receptionServiceReq_1.setCycleConfCode(omsEvaCycleConf.getCycleConfCode());//SimpleFieldAssign//sourceId:965535_1_42385
                }

                /*约定出参：周期配置标识[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getCycleConfCode(), "D3-分析时段规则设置(公共)-约定出参：周期配置标识-周期配置标识不能为空", false);
                receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        } else if ((queryConfItemMatchEvaTempAnswerDetailComRespDto != null && queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel() != null && queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel().equals("UNLIMITED"))) {
            //elseif(D2-3查时段规则设置规则配置.时段规则设置级别 等于 不限)  42374

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            receptionServiceReq_2.setCycleConfCode("UNLIMITED");//CUSTOM_CONVENTION//sourceId:965685_1_42383

            /*周期配置不限[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getCycleConfCode(), "D3-分析时段规则设置(公共)-周期配置不限-周期配置标识不能为空", false);
            receptionServiceRes_3 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes_3 != null) {
                receptionServiceReq_3.setCycleConfCode(receptionServiceRes_3.getCycleConfCode());//SimpleFieldAssign//sourceId:965535_1_42384
            }

            /*约定出参：周期配置标识[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getCycleConfCode(), "D3-分析时段规则设置(公共)-约定出参：周期配置标识-周期配置标识不能为空", false);
            receptionServiceRes_5 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


            receptionServiceRes_1 = receptionServiceRes_5;
        }
        ImplementTimeRulesSetLevelComRespDto retData = new ImplementTimeRulesSetLevelComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setCycleConfCode(receptionServiceRes_1.getCycleConfCode());//SimpleFieldAssign//sourceId:965694_1
        }


        return retData;
    }

    /**
     * D3-根据目标周期实际开始结束时间找周期(公共)[6885]
     * gen by moon at 11/9/2023, 10:29:51 PM
     */
    @Trace(operationName = "D3-根据目标周期实际开始结束时间找周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementFindExecuteCycleByActualWorkTimeComRespDto implementFindExecuteCycleByActualWorkTimeCom(ImplementFindExecuteCycleByActualWorkTimeComReqDto reqDto) {


        OmsCycle omsCycle_1 = null;
        Long getDateTimeOrderNumRes_1 = null;
        if ((reqDto != null && reqDto.getTargetActualStartTime() != null)) {
            //if(D3-根据目标周期实际开始结束时间切执行周期(公共).目标实际开始时间 值不等于空 )  42400

            OmsCycle omsCycle = null;
            QueryTimeMatchCycleDetailReq queryTimeMatchCycleDetailReq = new QueryTimeMatchCycleDetailReq();
            queryTimeMatchCycleDetailReq.setIsArchive("FALSE");//sourceId:966001_1_42403
            if (reqDto != null) {
                queryTimeMatchCycleDetailReq.setCycleStartTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:965997_1_42403
                queryTimeMatchCycleDetailReq.setCycleEndTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:965998_1_42403
                queryTimeMatchCycleDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:965999_1_42403
                queryTimeMatchCycleDetailReq.setPlatformData(reqDto.getPlatformData());//SimpleFieldAssign//sourceId:966000_1_42403
                queryTimeMatchCycleDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:966002_1_42403
            }

            /*3-4-04查询时间匹配周期详情（开始小于结束大于）[4985]   */
            Assert.isNull(queryTimeMatchCycleDetailReq.getCycleStartTime(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期开始时间不能为空", false);
            Assert.isNull(queryTimeMatchCycleDetailReq.getCycleEndTime(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期结束时间不能为空", false);
            Assert.isNull(queryTimeMatchCycleDetailReq.getCycleTypeCode(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期类型标识不能为空", false);
            Assert.isNull(queryTimeMatchCycleDetailReq.getPlatformData(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否是平台不能为空", false);
            Assert.isNull(queryTimeMatchCycleDetailReq.getIsArchive(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否存档不能为空", false);
            omsCycle = mOmsCycleService.queryTimeMatchCycleDetail(queryTimeMatchCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            omsCycle_1 = omsCycle;
//ModelCode: getDateTimeOrderNum
            // TODO: 2023/5/25 手动打码不要合
            if (omsCycle != null) {
                Long getDateTimeOrderNumRes = CommonFunctionHelper.getDateTimeOrderNum(reqDto.getTargetActualStartTime(), omsCycle.getCycleEndTime());
                getDateTimeOrderNumRes_1 = getDateTimeOrderNumRes;
            }


        }
        if ((reqDto != null && reqDto.getTargetActualEndtTime() != null)) {
            //if(D3-根据目标周期实际开始结束时间切执行周期(公共).目标实际结束时间 值不等于空 )  42402

            OmsCycle omsCycle_2 = null;
            QueryTimeMatchCycleDetailReq queryTimeMatchCycleDetailReq_1 = new QueryTimeMatchCycleDetailReq();
            queryTimeMatchCycleDetailReq_1.setIsArchive("FALSE");//sourceId:966001_1_42405
            if (reqDto != null) {
                queryTimeMatchCycleDetailReq_1.setCycleStartTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:965997_1_42405
                queryTimeMatchCycleDetailReq_1.setCycleEndTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:965998_1_42405
                queryTimeMatchCycleDetailReq_1.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:965999_1_42405
                queryTimeMatchCycleDetailReq_1.setPlatformData(reqDto.getPlatformData());//SimpleFieldAssign//sourceId:966000_1_42405
                queryTimeMatchCycleDetailReq_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:966002_1_42405
            }

            /*3-4-04查询时间匹配周期详情（开始小于结束大于）[4985]   */
            Assert.isNull(queryTimeMatchCycleDetailReq_1.getCycleStartTime(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期开始时间不能为空", false);
            Assert.isNull(queryTimeMatchCycleDetailReq_1.getCycleEndTime(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期结束时间不能为空", false);
            Assert.isNull(queryTimeMatchCycleDetailReq_1.getCycleTypeCode(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期类型标识不能为空", false);
            Assert.isNull(queryTimeMatchCycleDetailReq_1.getPlatformData(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否是平台不能为空", false);
            Assert.isNull(queryTimeMatchCycleDetailReq_1.getIsArchive(), "D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否存档不能为空", false);
            omsCycle_2 = mOmsCycleService.queryTimeMatchCycleDetail(queryTimeMatchCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            omsCycle_1 = omsCycle_2;
//ModelCode: getDateTimeOrderNum
            // TODO: 2023/5/25 手动代码，不要合
            if (omsCycle_2 != null) {
                Long getDateTimeOrderNumRes_2 = CommonFunctionHelper.getDateTimeOrderNum(omsCycle_2.getCycleStartTime(), reqDto.getTargetActualEndtTime());
                getDateTimeOrderNumRes_1 = getDateTimeOrderNumRes_2;
            }


        }
        ImplementFindExecuteCycleByActualWorkTimeComRespDto retData = new ImplementFindExecuteCycleByActualWorkTimeComRespDto();
        if (omsCycle_1 != null) {
            retData.setCycleId(omsCycle_1.getCycleId());//SimpleFieldAssign//sourceId:966041_1
            retData.setCycleStandardName(omsCycle_1.getCycleStandardName());//SimpleFieldAssign//sourceId:966042_1
            retData.setCycleStartTime(omsCycle_1.getCycleStartTime());//SimpleFieldAssign//sourceId:966043_1
            retData.setCycleEndTime(omsCycle_1.getCycleEndTime());//SimpleFieldAssign//sourceId:966044_1
            retData.setCycleTypeCode(omsCycle_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:966045_1
            retData.setCycleTypeInstanceCode(omsCycle_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1604993_1
        }
        if (getDateTimeOrderNumRes_1 != null) {
            // TODO: 2023/5/23 手写代码
            retData.setOrderNumber(getDateTimeOrderNumRes_1 != null ? getDateTimeOrderNumRes_1.longValue() : null);//SimpleFieldAssign//sourceId:966046_1
        }


        return retData;
    }

    /**
     * D3-执行克隆标准过程执行周期(公共)[6896]
     * gen by moon at 5/21/2023, 6:47:12 PM
     */
    @Trace(operationName = "D3-执行克隆标准过程执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCloneStdProExcCycleComRespDto implementCloneStdProExcCycleCom(ImplementCloneStdProExcCycleComReqDto reqDto) {


        //virtualUsage M3周期【循环开始】  42505
        //ModelCode: circulationCollections
        for (TargetContPlanWorkTimeDto circulationCollectionsRes : reqDto.getTargetContPlanWorkTimeList()) {

//virtualUsage 3-3-09查被评对象目标周期详情  42506
            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:969596_1_42506
            if (circulationCollectionsRes != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:969594_1_42506
            }
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:969595_1_42506
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-执行克隆标准过程执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行克隆标准过程执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行克隆标准过程执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）  42507
            List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
            QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq = new QuerySubCycleExecuteCycleStageListReq();
            querySubCycleExecuteCycleStageListReq.setIsProcessCycleStage("TRUE");//sourceId:969857_1_42507
            querySubCycleExecuteCycleStageListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:969859_1_42507
            if (circulationCollectionsRes != null) {
                querySubCycleExecuteCycleStageListReq.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:969855_1_42507
                querySubCycleExecuteCycleStageListReq.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:969856_1_42507
            }
            if (reqDto != null) {
                querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:969858_1_42507
            }

            /*3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）[4718]   */
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleStartTime(), "D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空", false);
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(), "D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空", false);
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(), "D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空", false);
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getIsProcessCycleStage(), "D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-是否过程周期阶段不能为空", false);
            Assert.isNull(querySubCycleExecuteCycleStageListReq.getSubjectLifeCycle(), "D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-主体生命周期不能为空", false);
            listOmsExecuteCycleStage = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-3-07批量增执行周期阶段  42511
            boolean bOOLEAN;
            if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0 && omsEvaluationObjectTargetCycle != null) {
                List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 = new ArrayList<>();
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                    OmsEvaluationObjectTargetCycle finalOmsEvaluationObjectTargetCycle = omsEvaluationObjectTargetCycle;
                    listOmsExecuteCycleStage_2 = //objList-to-objLists
                            listOmsExecuteCycleStage.stream().map(item -> {
                                OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
                                elm.setRelateExecuteCycleStageId(item.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:206630_2_42511
                                elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:206612_2_42511
                                elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:206636_2_42511
                                elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:206637_2_42511
                                elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:206638_2_42511
                                elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:206631_2_42511
                                elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:206632_2_42511
                                elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:206633_2_42511
                                elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:206634_2_42511
                                elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:206613_2_42511
                                elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:206615_2_42511
                                elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:206614_2_42511
                                elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:206616_2_42511
                                elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:206617_2_42511
                                elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:206639_2_42511
                                elm.setCycleTypeConfCode(item.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:206635_2_42511
                                elm.setTargetId(item.getTargetId());//SimpleFieldAssign//sourceId:206620_2_42511
                                elm.setEvaluationTemplateId(item.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:206621_2_42511
                                elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:206622_2_42511
                                elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:206623_2_42511
                                elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:206624_2_42511
                                elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:206625_2_42511
                                elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:206626_2_42511
                                elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:206627_2_42511
                                elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:206628_2_42511
                                elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:206629_2_42511
                                if (circulationCollectionsRes != null) {
                                    elm.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:206640_2_42511
                                }
                                if (finalOmsEvaluationObjectTargetCycle != null) {
                                    elm.setRelateContentTypeCode(finalOmsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:206618_2_42511
                                    elm.setRelateContentId(finalOmsEvaluationObjectTargetCycle.getTargetCycleContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:206619_2_42511
                                }
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:969521_1_42511
                }

                /*3-3-07批量增执行周期阶段[3151]   */

                bOOLEAN = mOmsExecuteCycleStageService.batchAddExecuteCycleStage(listOmsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;


            }
//virtualUsage M3-执行【循环结束】  42512
            //ModelCode: circulationEnd
        }

        ImplementCloneStdProExcCycleComRespDto retData = new ImplementCloneStdProExcCycleComRespDto();


        return retData;
    }

    /**
     * D3-执行克隆标准工作执行周期(公共)[6897]
     * gen by moon at 5/22/2023, 11:33:38 PM
     */
    @Trace(operationName = "D3-执行克隆标准工作执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCloneStdWorkExcCycleComRespDto implementCloneStdWorkExcCycleCom(ImplementCloneStdWorkExcCycleComReqDto reqDto) {


        //virtualUsage M3周期【循环开始】  42518
        //ModelCode: circulationCollections
        for (TargetContPlanWorkTimeDto circulationCollectionsRes : reqDto.getTargetContPlanWorkTimeList()) {

//virtualUsage 3-3-09查被评对象目标周期详情  42524
            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:970881_1_42524
            if (circulationCollectionsRes != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:970879_1_42524
            }
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970880_1_42524
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-3-07查询执行周期阶段详情  42525
            OmsExecuteCycleStage omsExecuteCycleStage = null;
            if (omsEvaluationObjectTargetCycle != null) {
                QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
                queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:970894_1_42525
                if (omsEvaluationObjectTargetCycle != null) {
                    queryExecuteCycleStageDetailReq.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:970889_1_42525
                    queryExecuteCycleStageDetailReq.setIsSubCycle(omsEvaluationObjectTargetCycle.getIsSubCycle());//SimpleFieldAssign//sourceId:970891_1_42525
                }
                if (reqDto != null) {
                    queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42525
                }

                /*3-3-07查询执行周期阶段详情[2429]   */
                Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
                omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            }
//virtualUsage 3-3-07新增执行周期阶段  42526
            String string = null;
            if (omsExecuteCycleStage != null && omsEvaluationObjectTargetCycle != null) {
                OmsExecuteCycleStage omsExecuteCycleStage_2 = new OmsExecuteCycleStage();
                omsExecuteCycleStage_2.setIsDefinedExecuteCycleStage("TRUE");//sourceId:970331_1_42526
                if (circulationCollectionsRes != null) {
                    omsExecuteCycleStage_2.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:970352_1_42526
                    omsExecuteCycleStage_2.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970346_1_42526
                    omsExecuteCycleStage_2.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970347_1_42526
                    omsExecuteCycleStage_2.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970340_1_42526
                    omsExecuteCycleStage_2.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970341_1_42526
                    omsExecuteCycleStage_2.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970342_1_42526
                    omsExecuteCycleStage_2.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970343_1_42526
                }
                if (omsExecuteCycleStage != null) {
                    omsExecuteCycleStage_2.setCycleId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:970324_1_42526
                    omsExecuteCycleStage_2.setCycleStandardName(omsExecuteCycleStage.getCycleStandardName());//SimpleFieldAssign//sourceId:970345_1_42526
                    omsExecuteCycleStage_2.setCycleTypeCode(omsExecuteCycleStage.getCycleTypeCode());//SimpleFieldAssign//sourceId:970348_1_42526
                    omsExecuteCycleStage_2.setCycleTypeConfCode(omsExecuteCycleStage.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:970344_1_42526
                    omsExecuteCycleStage_2.setIsFatherCycle(omsExecuteCycleStage.getIsFatherCycle());//SimpleFieldAssign//sourceId:970327_1_42526
                    omsExecuteCycleStage_2.setIsSubCycle(omsExecuteCycleStage.getIsSubCycle());//SimpleFieldAssign//sourceId:970328_1_42526
                    omsExecuteCycleStage_2.setIsMetaphase(omsExecuteCycleStage.getIsMetaphase());//SimpleFieldAssign//sourceId:970329_1_42526
                    omsExecuteCycleStage_2.setIsProcessCycleStage(omsExecuteCycleStage.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:970330_1_42526
                    omsExecuteCycleStage_2.setTargetId(omsExecuteCycleStage.getTargetId());//SimpleFieldAssign//sourceId:970339_1_42526
                    omsExecuteCycleStage_2.setEvaluationTemplateId(omsExecuteCycleStage.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970334_1_42526
                    omsExecuteCycleStage_2.setIsStartCycle(omsExecuteCycleStage.getIsStartCycle());//SimpleFieldAssign//sourceId:970335_1_42526
                    omsExecuteCycleStage_2.setIsEndCycle(omsExecuteCycleStage.getIsEndCycle());//SimpleFieldAssign//sourceId:970336_1_42526
                    omsExecuteCycleStage_2.setIsLastCycle(omsExecuteCycleStage.getIsLastCycle());//SimpleFieldAssign//sourceId:970337_1_42526
                    omsExecuteCycleStage_2.setEvaTempCreateTime(omsExecuteCycleStage.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:970325_1_42526
                    omsExecuteCycleStage_2.setOrderNumber(omsExecuteCycleStage.getOrderNumber());//SimpleFieldAssign//sourceId:970326_1_42526
                    omsExecuteCycleStage_2.setIsCurrentCycle(omsExecuteCycleStage.getIsCurrentCycle());//SimpleFieldAssign//sourceId:970350_1_42526
                    omsExecuteCycleStage_2.setIsNextCycle(omsExecuteCycleStage.getIsNextCycle());//SimpleFieldAssign//sourceId:970351_1_42526
                    omsExecuteCycleStage_2.setNextCyclePeriod(omsExecuteCycleStage.getNextCyclePeriod());//SimpleFieldAssign//sourceId:970353_1_42526
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    omsExecuteCycleStage_2.setRelateContentTypeCode(omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:970332_1_42526
                    omsExecuteCycleStage_2.setRelateContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:970333_1_42526
                }

                /*3-3-07新增执行周期阶段[2354]   */
                Assert.isNull(omsExecuteCycleStage_2.getEvaObjTargetCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getCycleStandardName(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getCycleStartTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getCycleEndTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getFillStartTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getFillEndtTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getCycleTypeCode(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getIsFatherCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getIsSubCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getIsMetaphase(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getIsProcessCycleStage(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getIsDefinedExecuteCycleStage(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getRelateContentTypeCode(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getRelateContentId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getTargetId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getIsStartCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否开始周期不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getIsEndCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否截止周期不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getIsLastCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getEvaTempCreateTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空", false);
                Assert.isNull(omsExecuteCycleStage_2.getOrderNumber(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-排序不能为空", false);
                string = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;


            }
//virtualUsage M3-执行【循环结束】  42519
            //ModelCode: circulationEnd
        }

        if ((reqDto != null && reqDto.getTargetCycleParentCycleId() != null)) {
            //if(D3-执行克隆标准工作执行周期(公共).目标周期父周期ID 值不等于空 )  42527

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:970881_1_42530
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:970879_1_42530
                queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970880_1_42530
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTargetCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(), "D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            OmsTargetCyclePlanSet omsTargetCyclePlanSet = null;
            QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq = new QueryTargetCyclePsetDetailReq();
            if (reqDto != null) {
                queryTargetCyclePsetDetailReq.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:971183_1_42554
                queryTargetCyclePsetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:971177_1_42554
            }

            /*3-3-08查询目标周期规划设置详情[3368]   */
            Assert.isNull(queryTargetCyclePsetDetailReq.getEvaObjTargetCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-08查询目标周期规划设置详情-归属被评对象目标周期ID不能为空", false);
            Assert.isNull(queryTargetCyclePsetDetailReq.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-08查询目标周期规划设置详情-冗余评价模板ID不能为空", false);
            omsTargetCyclePlanSet = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            OmsExecuteCycleStage omsExecuteCycleStage_3 = null;
            if (omsEvaluationObjectTargetCycle_2 != null) {
                QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1 = new QueryExecuteCycleStageDetailReq();
                queryExecuteCycleStageDetailReq_1.setIsArchive("FALSE");//sourceId:970894_1_42551
                if (omsEvaluationObjectTargetCycle_2 != null) {
                    queryExecuteCycleStageDetailReq_1.setCycleId(omsEvaluationObjectTargetCycle_2.getCycleId());//SimpleFieldAssign//sourceId:970889_1_42551
                    queryExecuteCycleStageDetailReq_1.setRelateContentTypeCode(omsEvaluationObjectTargetCycle_2.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:971280_1_42551
                    queryExecuteCycleStageDetailReq_1.setRelateContentId(omsEvaluationObjectTargetCycle_2.getTargetCycleContentId());//SimpleFieldAssign//sourceId:971281_1_42551
                    queryExecuteCycleStageDetailReq_1.setIsFatherCycle(omsEvaluationObjectTargetCycle_2.getIsParentCycle());//SimpleFieldAssign//sourceId:970890_1_42551
                }
                if (reqDto != null) {
                    queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42551
                }

                /*3-3-07查询执行周期阶段详情[2429]   */
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsArchive(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
                omsExecuteCycleStage_3 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            }
            if ((omsExecuteCycleStage_3 == null)) {
                //if(3-3-07查是否已存在内容父周期执行周期.出参 值等于空 )  42552

                OmsExecuteCycleStage omsExecuteCycleStage_4 = null;
                if (omsEvaluationObjectTargetCycle_2 != null) {
                    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_2 = new QueryExecuteCycleStageDetailReq();
                    queryExecuteCycleStageDetailReq_2.setIsArchive("FALSE");//sourceId:970894_1_42555
                    if (reqDto != null) {
                        queryExecuteCycleStageDetailReq_2.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:971281_1_42555
                        queryExecuteCycleStageDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42555
                    }
                    if (omsEvaluationObjectTargetCycle_2 != null) {
                        queryExecuteCycleStageDetailReq_2.setIsFatherCycle(omsEvaluationObjectTargetCycle_2.getIsParentCycle());//SimpleFieldAssign//sourceId:970890_1_42555
                    }

                    /*3-3-07查询执行周期阶段详情[2429]   */
                    Assert.isNull(queryExecuteCycleStageDetailReq_2.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                    Assert.isNull(queryExecuteCycleStageDetailReq_2.getIsArchive(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
                    omsExecuteCycleStage_4 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


                }
                String string_2 = null;
                if (omsEvaluationObjectTargetCycle_2 != null && omsTargetCyclePlanSet != null && omsExecuteCycleStage_4 != null) {
                    OmsExecuteCycleStage omsExecuteCycleStage_5 = new OmsExecuteCycleStage();
                    omsExecuteCycleStage_5.setIsDefinedExecuteCycleStage("TRUE");//sourceId:970331_1_42556
                    if (reqDto != null) {
                        omsExecuteCycleStage_5.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:970352_1_42556
                        omsExecuteCycleStage_5.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970334_1_42556
                    }
                    if (omsEvaluationObjectTargetCycle_2 != null) {
                        omsExecuteCycleStage_5.setCycleId(omsEvaluationObjectTargetCycle_2.getCycleId());//SimpleFieldAssign//sourceId:970324_1_42556
                        omsExecuteCycleStage_5.setCycleStandardName(omsEvaluationObjectTargetCycle_2.getCycleStandardName());//SimpleFieldAssign//sourceId:970345_1_42556
                        omsExecuteCycleStage_5.setCycleTypeCode(omsEvaluationObjectTargetCycle_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:970348_1_42556
                        omsExecuteCycleStage_5.setIsFatherCycle(omsEvaluationObjectTargetCycle_2.getIsParentCycle());//SimpleFieldAssign//sourceId:970327_1_42556
                        omsExecuteCycleStage_5.setIsSubCycle(omsEvaluationObjectTargetCycle_2.getIsSubCycle());//SimpleFieldAssign//sourceId:970328_1_42556
                        omsExecuteCycleStage_5.setIsMetaphase(omsEvaluationObjectTargetCycle_2.getIsMetaphase());//SimpleFieldAssign//sourceId:970329_1_42556
                        omsExecuteCycleStage_5.setRelateContentTypeCode(omsEvaluationObjectTargetCycle_2.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:970332_1_42556
                        omsExecuteCycleStage_5.setRelateContentId(omsEvaluationObjectTargetCycle_2.getTargetCycleContentId());//SimpleFieldAssign//sourceId:970333_1_42556
                        omsExecuteCycleStage_5.setOrderNumber(omsEvaluationObjectTargetCycle_2.getOrderNumber());//SimpleFieldAssign//sourceId:970326_1_42556
                    }
                    if (omsTargetCyclePlanSet != null) {
                        omsExecuteCycleStage_5.setCycleStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970346_1_42556
                        omsExecuteCycleStage_5.setCycleEndTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970347_1_42556
                        omsExecuteCycleStage_5.setFillStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970340_1_42556
                        omsExecuteCycleStage_5.setFillEndtTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970341_1_42556
                        omsExecuteCycleStage_5.setEvaluateStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970342_1_42556
                        omsExecuteCycleStage_5.setEvaluateEndtTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970343_1_42556
                    }
                    if (omsExecuteCycleStage_4 != null) {
                        omsExecuteCycleStage_5.setCycleTypeConfCode(omsExecuteCycleStage_4.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:970344_1_42556
                        omsExecuteCycleStage_5.setIsProcessCycleStage(omsExecuteCycleStage_4.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:970330_1_42556
                        omsExecuteCycleStage_5.setTargetId(omsExecuteCycleStage_4.getTargetId());//SimpleFieldAssign//sourceId:970339_1_42556
                        omsExecuteCycleStage_5.setIsStartCycle(omsExecuteCycleStage_4.getIsStartCycle());//SimpleFieldAssign//sourceId:970335_1_42556
                        omsExecuteCycleStage_5.setIsEndCycle(omsExecuteCycleStage_4.getIsEndCycle());//SimpleFieldAssign//sourceId:970336_1_42556
                        omsExecuteCycleStage_5.setIsLastCycle(omsExecuteCycleStage_4.getIsLastCycle());//SimpleFieldAssign//sourceId:970337_1_42556
                        omsExecuteCycleStage_5.setEvaTempCreateTime(omsExecuteCycleStage_4.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:970325_1_42556
                        omsExecuteCycleStage_5.setIsCurrentCycle(omsExecuteCycleStage_4.getIsCurrentCycle());//SimpleFieldAssign//sourceId:970350_1_42556
                        omsExecuteCycleStage_5.setIsNextCycle(omsExecuteCycleStage_4.getIsNextCycle());//SimpleFieldAssign//sourceId:970351_1_42556
                        omsExecuteCycleStage_5.setNextCyclePeriod(omsExecuteCycleStage_4.getNextCyclePeriod());//SimpleFieldAssign//sourceId:970353_1_42556
                    }

                    /*3-3-07新增执行周期阶段[2354]   */
                    Assert.isNull(omsExecuteCycleStage_5.getEvaObjTargetCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getCycleStandardName(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getCycleStartTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getCycleEndTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getFillStartTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getFillEndtTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getCycleTypeCode(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getIsFatherCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getIsSubCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getIsMetaphase(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getIsProcessCycleStage(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getIsDefinedExecuteCycleStage(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getRelateContentTypeCode(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getRelateContentId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getTargetId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getIsStartCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否开始周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getIsEndCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否截止周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getIsLastCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getEvaTempCreateTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_5.getOrderNumber(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-排序不能为空", false);
                    string_2 = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_5)/*vcase invoke 本地 method 方法调用;*/;


                }
            } else if ((omsExecuteCycleStage_3 != null)) {
                //elseif(3-3-07查是否已存在内容父周期执行周期.出参 值不等于空 )  42553

                boolean bOOLEAN;
                if (omsExecuteCycleStage_3 != null && omsTargetCyclePlanSet != null) {
                    OmsExecuteCycleStage omsExecuteCycleStage_6 = new OmsExecuteCycleStage();
                    if (omsExecuteCycleStage_3 != null) {
                        omsExecuteCycleStage_6.setExecuteCycleStageId(omsExecuteCycleStage_3.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:971317_1_42558
                    }
                    if (omsTargetCyclePlanSet != null) {
                        omsExecuteCycleStage_6.setCycleStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971319_1_42558
                        omsExecuteCycleStage_6.setCycleEndTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971318_1_42558
                        omsExecuteCycleStage_6.setFillStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971320_1_42558
                        omsExecuteCycleStage_6.setFillEndtTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971321_1_42558
                        omsExecuteCycleStage_6.setEvaluateStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971322_1_42558
                        omsExecuteCycleStage_6.setEvaluateEndtTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971323_1_42558
                    }

                    /*3-3-07修改执行周期阶段[2489]   */
                    Assert.isNull(omsExecuteCycleStage_6.getExecuteCycleStageId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                    bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_6)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
        }
        if ((reqDto != null && reqDto.getTargetCycleMidCycleId() != null)) {
            //if(D3-执行克隆标准工作执行周期(公共). 目标周期中期ID 值不等于空 )  42529

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_3 = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2 = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq_2.setIsArchive("FALSE");//sourceId:970881_1_42533
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq_2.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:970879_1_42533
                queryEvaObjTargetCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970880_1_42533
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTargetCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsArchive(), "D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle_3 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


            OmsTargetCyclePlanSet omsTargetCyclePlanSet_2 = null;
            QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq_1 = new QueryTargetCyclePsetDetailReq();
            if (reqDto != null) {
                queryTargetCyclePsetDetailReq_1.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:971183_1_42549
                queryTargetCyclePsetDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:971177_1_42549
            }

            /*3-3-08查询目标周期规划设置详情[3368]   */
            Assert.isNull(queryTargetCyclePsetDetailReq_1.getEvaObjTargetCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-08查询目标周期规划设置详情-归属被评对象目标周期ID不能为空", false);
            Assert.isNull(queryTargetCyclePsetDetailReq_1.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-08查询目标周期规划设置详情-冗余评价模板ID不能为空", false);
            omsTargetCyclePlanSet_2 = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            OmsExecuteCycleStage omsExecuteCycleStage_7 = null;
            if (omsEvaluationObjectTargetCycle_3 != null) {
                QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_3 = new QueryExecuteCycleStageDetailReq();
                queryExecuteCycleStageDetailReq_3.setIsArchive("FALSE");//sourceId:970894_1_42535
                if (omsEvaluationObjectTargetCycle_3 != null) {
                    queryExecuteCycleStageDetailReq_3.setCycleId(omsEvaluationObjectTargetCycle_3.getCycleId());//SimpleFieldAssign//sourceId:970889_1_42535
                    queryExecuteCycleStageDetailReq_3.setRelateContentTypeCode(omsEvaluationObjectTargetCycle_3.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:971280_1_42535
                    queryExecuteCycleStageDetailReq_3.setRelateContentId(omsEvaluationObjectTargetCycle_3.getTargetCycleContentId());//SimpleFieldAssign//sourceId:971281_1_42535
                    queryExecuteCycleStageDetailReq_3.setIsMetaphase(omsEvaluationObjectTargetCycle_3.getIsMetaphase());//SimpleFieldAssign//sourceId:970892_1_42535
                }
                if (reqDto != null) {
                    queryExecuteCycleStageDetailReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42535
                }

                /*3-3-07查询执行周期阶段详情[2429]   */
                Assert.isNull(queryExecuteCycleStageDetailReq_3.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_3.getIsArchive(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
                omsExecuteCycleStage_7 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;


            }
            if ((omsExecuteCycleStage_7 == null)) {
                //if(3-3-07查是否已存在内容中期执行周期.出参 值等于空 )  42560

                OmsExecuteCycleStage omsExecuteCycleStage_8 = null;
                if (omsEvaluationObjectTargetCycle_3 != null) {
                    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_4 = new QueryExecuteCycleStageDetailReq();
                    queryExecuteCycleStageDetailReq_4.setIsArchive("FALSE");//sourceId:970894_1_42561
                    if (reqDto != null) {
                        queryExecuteCycleStageDetailReq_4.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:971281_1_42561
                        queryExecuteCycleStageDetailReq_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42561
                    }
                    if (omsEvaluationObjectTargetCycle_3 != null) {
                        queryExecuteCycleStageDetailReq_4.setIsMetaphase(omsEvaluationObjectTargetCycle_3.getIsMetaphase());//SimpleFieldAssign//sourceId:970892_1_42561
                    }

                    /*3-3-07查询执行周期阶段详情[2429]   */
                    Assert.isNull(queryExecuteCycleStageDetailReq_4.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                    Assert.isNull(queryExecuteCycleStageDetailReq_4.getIsArchive(), "D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
                    omsExecuteCycleStage_8 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_4)/*vcase invoke 本地 method 方法调用;*/;


                }
                String string_3 = null;
                if (omsEvaluationObjectTargetCycle_3 != null && omsTargetCyclePlanSet_2 != null && omsExecuteCycleStage_8 != null) {
                    OmsExecuteCycleStage omsExecuteCycleStage_9 = new OmsExecuteCycleStage();
                    omsExecuteCycleStage_9.setIsDefinedExecuteCycleStage("TRUE");//sourceId:970331_1_42562
                    if (reqDto != null) {
                        omsExecuteCycleStage_9.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:970352_1_42562
                        omsExecuteCycleStage_9.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970334_1_42562
                    }
                    if (omsEvaluationObjectTargetCycle_3 != null) {
                        omsExecuteCycleStage_9.setCycleId(omsEvaluationObjectTargetCycle_3.getCycleId());//SimpleFieldAssign//sourceId:970324_1_42562
                        omsExecuteCycleStage_9.setCycleStandardName(omsEvaluationObjectTargetCycle_3.getCycleStandardName());//SimpleFieldAssign//sourceId:970345_1_42562
                        omsExecuteCycleStage_9.setCycleTypeCode(omsEvaluationObjectTargetCycle_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:970348_1_42562
                        omsExecuteCycleStage_9.setIsFatherCycle(omsEvaluationObjectTargetCycle_3.getIsParentCycle());//SimpleFieldAssign//sourceId:970327_1_42562
                        omsExecuteCycleStage_9.setIsSubCycle(omsEvaluationObjectTargetCycle_3.getIsSubCycle());//SimpleFieldAssign//sourceId:970328_1_42562
                        omsExecuteCycleStage_9.setIsMetaphase(omsEvaluationObjectTargetCycle_3.getIsMetaphase());//SimpleFieldAssign//sourceId:970329_1_42562
                        omsExecuteCycleStage_9.setRelateContentTypeCode(omsEvaluationObjectTargetCycle_3.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:970332_1_42562
                        omsExecuteCycleStage_9.setRelateContentId(omsEvaluationObjectTargetCycle_3.getTargetCycleContentId());//SimpleFieldAssign//sourceId:970333_1_42562
                        omsExecuteCycleStage_9.setOrderNumber(omsEvaluationObjectTargetCycle_3.getOrderNumber());//SimpleFieldAssign//sourceId:970326_1_42562
                    }
                    if (omsTargetCyclePlanSet_2 != null) {
                        omsExecuteCycleStage_9.setCycleStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970346_1_42562
                        omsExecuteCycleStage_9.setCycleEndTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970347_1_42562
                        omsExecuteCycleStage_9.setFillStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970340_1_42562
                        omsExecuteCycleStage_9.setFillEndtTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970341_1_42562
                        omsExecuteCycleStage_9.setEvaluateStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970342_1_42562
                        omsExecuteCycleStage_9.setEvaluateEndtTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970343_1_42562
                    }
                    if (omsExecuteCycleStage_8 != null) {
                        omsExecuteCycleStage_9.setCycleTypeConfCode(omsExecuteCycleStage_8.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:970344_1_42562
                        omsExecuteCycleStage_9.setIsProcessCycleStage(omsExecuteCycleStage_8.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:970330_1_42562
                        omsExecuteCycleStage_9.setTargetId(omsExecuteCycleStage_8.getTargetId());//SimpleFieldAssign//sourceId:970339_1_42562
                        omsExecuteCycleStage_9.setIsStartCycle(omsExecuteCycleStage_8.getIsStartCycle());//SimpleFieldAssign//sourceId:970335_1_42562
                        omsExecuteCycleStage_9.setIsEndCycle(omsExecuteCycleStage_8.getIsEndCycle());//SimpleFieldAssign//sourceId:970336_1_42562
                        omsExecuteCycleStage_9.setIsLastCycle(omsExecuteCycleStage_8.getIsLastCycle());//SimpleFieldAssign//sourceId:970337_1_42562
                        omsExecuteCycleStage_9.setEvaTempCreateTime(omsExecuteCycleStage_8.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:970325_1_42562
                        omsExecuteCycleStage_9.setIsCurrentCycle(omsExecuteCycleStage_8.getIsCurrentCycle());//SimpleFieldAssign//sourceId:970350_1_42562
                        omsExecuteCycleStage_9.setIsNextCycle(omsExecuteCycleStage_8.getIsNextCycle());//SimpleFieldAssign//sourceId:970351_1_42562
                        omsExecuteCycleStage_9.setNextCyclePeriod(omsExecuteCycleStage_8.getNextCyclePeriod());//SimpleFieldAssign//sourceId:970353_1_42562
                    }

                    /*3-3-07新增执行周期阶段[2354]   */
                    Assert.isNull(omsExecuteCycleStage_9.getEvaObjTargetCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getCycleId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getCycleStandardName(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getCycleStartTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getCycleEndTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getFillStartTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getFillEndtTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getCycleTypeCode(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getIsFatherCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getIsSubCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getIsMetaphase(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getIsProcessCycleStage(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getIsDefinedExecuteCycleStage(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getRelateContentTypeCode(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getRelateContentId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getTargetId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getEvaluationTemplateId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getIsStartCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否开始周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getIsEndCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否截止周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getIsLastCycle(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getEvaTempCreateTime(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空", false);
                    Assert.isNull(omsExecuteCycleStage_9.getOrderNumber(), "D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-排序不能为空", false);
                    string_3 = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_9)/*vcase invoke 本地 method 方法调用;*/;


                }
            } else if ((omsExecuteCycleStage_7 != null)) {
                //elseif(3-3-07查是否已存在内容中期执行周期.出参 值不等于空 )  42563

                boolean bOOLEAN_1;
                if (omsExecuteCycleStage_7 != null && omsTargetCyclePlanSet_2 != null) {
                    OmsExecuteCycleStage omsExecuteCycleStage_10 = new OmsExecuteCycleStage();
                    if (omsExecuteCycleStage_7 != null) {
                        omsExecuteCycleStage_10.setExecuteCycleStageId(omsExecuteCycleStage_7.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:971317_1_42564
                    }
                    if (omsTargetCyclePlanSet_2 != null) {
                        omsExecuteCycleStage_10.setCycleStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971319_1_42564
                        omsExecuteCycleStage_10.setCycleEndTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971318_1_42564
                        omsExecuteCycleStage_10.setFillStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971320_1_42564
                        omsExecuteCycleStage_10.setFillEndtTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971321_1_42564
                        omsExecuteCycleStage_10.setEvaluateStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971322_1_42564
                        omsExecuteCycleStage_10.setEvaluateEndtTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971323_1_42564
                    }

                    /*3-3-07修改执行周期阶段[2489]   */
                    Assert.isNull(omsExecuteCycleStage_10.getExecuteCycleStageId(), "D3-执行克隆标准工作执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                    bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_10)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
        }
        ImplementCloneStdWorkExcCycleComRespDto retData = new ImplementCloneStdWorkExcCycleComRespDto();


        return retData;
    }

    /**
     * D3-执行补偿克隆过程执行周期(公共)[6898]
     * gen by moon at 5/21/2023, 10:18:35 PM
     */
    @Trace(operationName = "D3-执行补偿克隆过程执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCompCloneProExcCycleComRespDto implementCompCloneProExcCycleCom(ImplementCompCloneProExcCycleComReqDto reqDto) {


        //virtualUsage M3周期【循环开始】  42570
        //ModelCode: circulationCollections
        for (TargetContPlanWorkTimeDto circulationCollectionsRes : reqDto.getTargetContPlanWorkTimeList()) {

//virtualUsage 3-3-09查被评对象目标周期详情  42599
            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:972315_1_42599
            if (circulationCollectionsRes != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:972313_1_42599
            }
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972314_1_42599
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-执行补偿克隆过程执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行补偿克隆过程执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行补偿克隆过程执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-3-7查询执行周期列表（开始时间小于&结束时间大于）  42583
            List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
            QueryExecuteCycleSmallStartListReq queryExecuteCycleSmallStartListReq = new QueryExecuteCycleSmallStartListReq();
            queryExecuteCycleSmallStartListReq.setIsProcessCycleStage("TRUE");//sourceId:971946_1_42583
            if (circulationCollectionsRes != null) {
                queryExecuteCycleSmallStartListReq.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971939_1_42583
                queryExecuteCycleSmallStartListReq.setCycleEndTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971940_1_42583
            }
            if (reqDto != null) {
                queryExecuteCycleSmallStartListReq.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:971991_1_42583
                queryExecuteCycleSmallStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:971949_1_42583
            }

            /*3-3-7查询执行周期列表（开始时间小于&结束时间大于）[6900]   */
            Assert.isNull(queryExecuteCycleSmallStartListReq.getCycleStartTime(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-周期开始时间不能为空", false);
            Assert.isNull(queryExecuteCycleSmallStartListReq.getCycleEndTime(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-周期结束时间不能为空", false);
            Assert.isNull(queryExecuteCycleSmallStartListReq.getIsProcessCycleStage(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-是否过程周期阶段不能为空", false);
            Assert.isNull(queryExecuteCycleSmallStartListReq.getRelateContentId(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-关联目标内容ID不能为空", false);
            Assert.isNull(queryExecuteCycleSmallStartListReq.getEvaluationTemplateId(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-评价模板ID不能为空", false);
            listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleSmallStartList(queryExecuteCycleSmallStartListReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((listOmsExecuteCycleStage != null && listOmsExecuteCycleStage != null && listOmsExecuteCycleStage.size() > 0)) {
                //if(3-3-7查开始时间匹配的执行周期列表.执行周期阶段列表数据集条数 大于 0)  42592

                boolean bOOLEAN;
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0 && omsEvaluationObjectTargetCycle != null) {
                    List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 = new ArrayList<>();
                    if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                        OmsEvaluationObjectTargetCycle finalOmsEvaluationObjectTargetCycle = omsEvaluationObjectTargetCycle;
                        listOmsExecuteCycleStage_2 = //objList-to-objLists
                                listOmsExecuteCycleStage.stream().map(item -> {
                                    OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
                                    elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:207304_2_42595
                                    elm.setRelateExecuteCycleStageId(item.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:207293_2_42595
                                    elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:207303_2_42595
                                    elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:207275_2_42595
                                    elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:207299_2_42595
                                    elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:207301_2_42595
                                    elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:207295_2_42595
                                    elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:207297_2_42595
                                    elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:207276_2_42595
                                    elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:207277_2_42595
                                    elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:207278_2_42595
                                    elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:207279_2_42595
                                    elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:207280_2_42595
                                    elm.setCycleTypeConfCode(item.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:207298_2_42595
                                    elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:207302_2_42595
                                    elm.setTargetId(item.getTargetId());//SimpleFieldAssign//sourceId:207283_2_42595
                                    elm.setEvaluationTemplateId(item.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:207284_2_42595
                                    elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:207285_2_42595
                                    elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:207286_2_42595
                                    elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:207287_2_42595
                                    elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:207288_2_42595
                                    elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:207289_2_42595
                                    elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:207290_2_42595
                                    elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:207291_2_42595
                                    elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:207292_2_42595
                                    if (circulationCollectionsRes != null) {
                                        elm.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207300_2_42595
                                        elm.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207294_2_42595
                                        elm.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207296_2_42595
                                    }
                                    if (finalOmsEvaluationObjectTargetCycle != null) {
                                        elm.setRelateContentTypeCode(finalOmsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207281_2_42595
                                        elm.setRelateContentId(finalOmsEvaluationObjectTargetCycle.getTargetCycleContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207282_2_42595
                                    }
                                    return elm;
                                }).collect(Collectors.toList());//objList-to-objLists//sourceId:972057_1_42595
                    }

                    /*3-3-07批量增执行周期阶段[3151]   */

                    bOOLEAN = mOmsExecuteCycleStageService.batchAddExecuteCycleStage(listOmsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
//virtualUsage 3-3-7查询执行周期列表（开始时间小于&结束时间大于）  42596
            List<OmsExecuteCycleStage> listOmsExecuteCycleStage_3 = new ArrayList<>();
            QueryExecuteCycleSmallStartListReq queryExecuteCycleSmallStartListReq_1 = new QueryExecuteCycleSmallStartListReq();
            queryExecuteCycleSmallStartListReq_1.setIsProcessCycleStage("TRUE");//sourceId:971946_1_42596
            if (circulationCollectionsRes != null) {
                queryExecuteCycleSmallStartListReq_1.setCycleStartTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971939_1_42596
                queryExecuteCycleSmallStartListReq_1.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971940_1_42596
            }
            if (reqDto != null) {
                queryExecuteCycleSmallStartListReq_1.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:971991_1_42596
                queryExecuteCycleSmallStartListReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:971949_1_42596
            }

            /*3-3-7查询执行周期列表（开始时间小于&结束时间大于）[6900]   */
            Assert.isNull(queryExecuteCycleSmallStartListReq_1.getCycleStartTime(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-周期开始时间不能为空", false);
            Assert.isNull(queryExecuteCycleSmallStartListReq_1.getCycleEndTime(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-周期结束时间不能为空", false);
            Assert.isNull(queryExecuteCycleSmallStartListReq_1.getIsProcessCycleStage(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-是否过程周期阶段不能为空", false);
            Assert.isNull(queryExecuteCycleSmallStartListReq_1.getRelateContentId(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-关联目标内容ID不能为空", false);
            Assert.isNull(queryExecuteCycleSmallStartListReq_1.getEvaluationTemplateId(), "D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-评价模板ID不能为空", false);
            listOmsExecuteCycleStage_3 = mOmsExecuteCycleStageService.queryExecuteCycleSmallStartList(queryExecuteCycleSmallStartListReq_1)/*vcase invoke 本地 method 方法调用;*/;


            if ((listOmsExecuteCycleStage_3 != null && listOmsExecuteCycleStage_3 != null && listOmsExecuteCycleStage_3.size() > 0)) {
                //if(3-3-7查结束时间匹配的执行周期列表.执行周期阶段列表数据集条数 大于 0)  42597

                boolean bOOLEAN_1;
                if (listOmsExecuteCycleStage_3 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_3) && listOmsExecuteCycleStage_3.size() > 0 && omsEvaluationObjectTargetCycle != null) {
                    List<OmsExecuteCycleStage> listOmsExecuteCycleStage_4 = new ArrayList<>();
                    if (listOmsExecuteCycleStage_3 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_3) && listOmsExecuteCycleStage_3 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_3)) {
                        OmsEvaluationObjectTargetCycle finalOmsEvaluationObjectTargetCycle1 = omsEvaluationObjectTargetCycle;
                        listOmsExecuteCycleStage_4 = //objList-to-objLists
                                listOmsExecuteCycleStage_3.stream().map(item -> {
                                    OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
                                    elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:207304_2_42598
                                    elm.setRelateExecuteCycleStageId(item.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:207293_2_42598
                                    elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:207303_2_42598
                                    elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:207275_2_42598
                                    elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:207299_2_42598
                                    elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:207300_2_42598
                                    elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:207294_2_42598
                                    elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:207296_2_42598
                                    elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:207276_2_42598
                                    elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:207277_2_42598
                                    elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:207278_2_42598
                                    elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:207279_2_42598
                                    elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:207280_2_42598
                                    elm.setCycleTypeConfCode(item.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:207298_2_42598
                                    elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:207302_2_42598
                                    elm.setTargetId(item.getTargetId());//SimpleFieldAssign//sourceId:207283_2_42598
                                    elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:207285_2_42598
                                    elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:207286_2_42598
                                    elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:207287_2_42598
                                    elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:207288_2_42598
                                    elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:207289_2_42598
                                    elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:207290_2_42598
                                    elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:207291_2_42598
                                    elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:207292_2_42598
                                    if (circulationCollectionsRes != null) {
                                        elm.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207301_2_42598
                                        elm.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207295_2_42598
                                        elm.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207297_2_42598
                                    }
                                    if (finalOmsEvaluationObjectTargetCycle1 != null) {
                                        elm.setRelateContentTypeCode(finalOmsEvaluationObjectTargetCycle1.getTargetCycleContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207281_2_42598
                                        elm.setRelateContentId(finalOmsEvaluationObjectTargetCycle1.getTargetCycleContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207282_2_42598
                                    }
                                    if (reqDto != null) {
                                        elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207284_2_42598
                                    }
                                    return elm;
                                }).collect(Collectors.toList());//objList-to-objLists//sourceId:972057_1_42598
                    }

                    /*3-3-07批量增执行周期阶段[3151]   */

                    bOOLEAN_1 = mOmsExecuteCycleStageService.batchAddExecuteCycleStage(listOmsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
//virtualUsage M3-执行【循环结束】  42571
            //ModelCode: circulationEnd
        }

        ImplementCompCloneProExcCycleComRespDto retData = new ImplementCompCloneProExcCycleComRespDto();


        return retData;
    }

    /**
     * D3-执行自定义汇报克隆标准执行周期(公共)[6895]
     * gen by moon at 5/21/2023, 10:18:52 PM
     */
    @Trace(operationName = "D3-执行自定义汇报克隆标准执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCustomizeReportCloneStdExcCycleComRespDto implementCustomizeReportCloneStdExcCycleCom(ImplementCustomizeReportCloneStdExcCycleComReqDto reqDto) {


        //virtualUsage D3-执行克隆标准过程执行周期(公共)  42588
        ImplementCloneStdProExcCycleComRespDto implementCloneStdProExcCycleComRespDto = null;
        ImplementCloneStdProExcCycleComReqDto implementCloneStdProExcCycleComReqDto = new ImplementCloneStdProExcCycleComReqDto();
        if (reqDto != null && reqDto.getTargetContPlanWorkTimeList() != null && !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())) {
            implementCloneStdProExcCycleComReqDto.setTargetContPlanWorkTimeList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972013_1_42588
        }
        if (reqDto != null) {
            implementCloneStdProExcCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972014_1_42588
        }

        /*D3-执行克隆标准过程执行周期(公共)[6896]   */
        Assert.isNull(implementCloneStdProExcCycleComReqDto.getEvaluationTemplateId(), "D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行克隆标准过程执行周期(公共)-冗余评价模板ID不能为空", false);
        implementCloneStdProExcCycleComRespDto = implementCloneStdProExcCycleCom(implementCloneStdProExcCycleComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D3-执行克隆标准工作执行周期(公共)  42589
        ImplementCloneStdWorkExcCycleComRespDto implementCloneStdWorkExcCycleComRespDto = null;
        ImplementCloneStdWorkExcCycleComReqDto implementCloneStdWorkExcCycleComReqDto = new ImplementCloneStdWorkExcCycleComReqDto();
        if (reqDto != null && reqDto.getTargetContPlanWorkTimeList() != null && !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())) {
            implementCloneStdWorkExcCycleComReqDto.setTargetContPlanWorkTimeList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972015_1_42589
        }
        if (reqDto != null) {
            implementCloneStdWorkExcCycleComReqDto.setTargetCycleParentCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:972016_1_42589
            implementCloneStdWorkExcCycleComReqDto.setTargetCycleMidCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:972018_1_42589
            implementCloneStdWorkExcCycleComReqDto.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:972017_1_42589
            implementCloneStdWorkExcCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:972431_1_42589
            implementCloneStdWorkExcCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972019_1_42589
        }

        /*D3-执行克隆标准工作执行周期(公共)[6897]   */
        Assert.isNull(implementCloneStdWorkExcCycleComReqDto.getTargetId(), "D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行克隆标准工作执行周期(公共)-冗余目标ID不能为空", false);
        Assert.isNull(implementCloneStdWorkExcCycleComReqDto.getEvaluationTemplateId(), "D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行克隆标准工作执行周期(公共)-冗余评价模板ID不能为空", false);
        implementCloneStdWorkExcCycleComRespDto = implementCloneStdWorkExcCycleCom(implementCloneStdWorkExcCycleComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D3-执行补偿克隆过程执行周期(公共)  42591
        ImplementCompCloneProExcCycleComRespDto implementCompCloneProExcCycleComRespDto = null;
        ImplementCompCloneProExcCycleComReqDto implementCompCloneProExcCycleComReqDto = new ImplementCompCloneProExcCycleComReqDto();
        if (reqDto != null && reqDto.getTargetContPlanWorkTimeList() != null && !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())) {
            implementCompCloneProExcCycleComReqDto.setTargetContPlanWorkTimeList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972020_1_42591
        }
        if (reqDto != null) {
            implementCompCloneProExcCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:972022_1_42591
            implementCompCloneProExcCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972021_1_42591
        }

        /*D3-执行补偿克隆过程执行周期(公共)[6898]   */
        Assert.isNull(implementCompCloneProExcCycleComReqDto.getTargetId(), "D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行补偿克隆过程执行周期(公共)-冗余目标ID不能为空", false);
        Assert.isNull(implementCompCloneProExcCycleComReqDto.getEvaluationTemplateId(), "D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行补偿克隆过程执行周期(公共)-冗余评价模板ID不能为空", false);
        implementCompCloneProExcCycleComRespDto = implementCompCloneProExcCycleCom(implementCompCloneProExcCycleComReqDto)/*vcase invoke 同服务,同domain*/;


        ImplementCustomizeReportCloneStdExcCycleComRespDto retData = new ImplementCustomizeReportCloneStdExcCycleComRespDto();


        return retData;
    }

    /**
     * D3-获取执行周期时段规则(公共)[6903]
     * gen by moon at 7/6/2024, 11:57:07 PM
     */
    @Trace(operationName = "D3-获取执行周期时段规则(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainExecuteCycleTimeRuleComRespDto obtainExecuteCycleTimeRuleCom(ObtainExecuteCycleTimeRuleComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
//virtualUsage M3-约定字段：是否  71368
        //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
        ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
        receptionServiceReq.setCustomField1("TRUE");//CUSTOM_CONVENTION//sourceId:1923319_1_71368
        receptionServiceReq.setCustomField2("FALSE");//CUSTOM_CONVENTION//sourceId:1923320_1_71368

        /*M3-约定字段：是否[9482]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D3-获取执行周期时段规则(公共)-M3-约定字段：是否-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D3-获取执行周期时段规则(公共)-M3-约定字段：是否-自定义字段2不能为空", false);
        receptionServiceRes = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq);


        if ((reqDto != null && reqDto.getTimeRulesSetLevel() != null && reqDto.getTimeRulesSetLevel().equals("EVA_TEMP_LEVEL"))) {
            //if(D3-获取执行周期时段规则(公共).时段规则设置级别 等于 评价模板级)  42606

            ObtainCycleTimeRuleInfoComRespDto obtainCycleTimeRuleInfoComRespDto = null;
            ObtainCycleTimeRuleInfoComReqDto obtainCycleTimeRuleInfoComReqDto = new ObtainCycleTimeRuleInfoComReqDto();
            if (reqDto != null && reqDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())) {
                obtainCycleTimeRuleInfoComReqDto.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972791_1_68148
            }
            if (reqDto != null) {
                obtainCycleTimeRuleInfoComReqDto.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:972792_1_68148
                obtainCycleTimeRuleInfoComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:972790_1_68148
                obtainCycleTimeRuleInfoComReqDto.setTimeRuleCode(reqDto.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:1784923_1_68148
                obtainCycleTimeRuleInfoComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784922_1_68148
                obtainCycleTimeRuleInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972793_1_68148
            }

            /*D3-2时段规则分析4个时间点(公共)[3519]   */
            Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getExecuteCycleStageId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-执行周期阶段ID不能为空", false);
            Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getCycleId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期ID不能为空", false);
            Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getTimeRuleCode(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-时段规则标识不能为空", false);
            Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getCycleTypeCode(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期类型标识不能为空", false);
            Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getEvaluationTemplateId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-冗余评价模板ID不能为空", false);
            obtainCycleTimeRuleInfoComRespDto = cycleConfService.obtainCycleTimeRuleInfoCom(obtainCycleTimeRuleInfoComReqDto)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            if (obtainCycleTimeRuleInfoComRespDto != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                if (obtainCycleTimeRuleInfoComRespDto != null) {
                    receptionServiceReq_1.setTimePeriodStartTime(obtainCycleTimeRuleInfoComRespDto.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973015_1_42614
                    receptionServiceReq_1.setTimePeriodEndTime(obtainCycleTimeRuleInfoComRespDto.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973016_1_42614
                    receptionServiceReq_1.setComTimeField1(obtainCycleTimeRuleInfoComRespDto.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973030_1_42614
                    receptionServiceReq_1.setComTimeField2(obtainCycleTimeRuleInfoComRespDto.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973031_1_42614
                }

                /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getTimePeriodStartTime(), "D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段开始时间不能为空", false);
                Assert.isNull(receptionServiceReq_1.getTimePeriodEndTime(), "D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段结束时间不能为空", false);
                receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


                receptionServiceRes_3 = receptionServiceRes_2;
            }
        } else if ((reqDto != null && reqDto.getTimeRulesSetLevel() != null && reqDto.getTimeRulesSetLevel().equals("CYCLE_TYPE_LEVEL") && reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
            //elseif((D3-获取执行周期时段规则(公共).时段规则设置级别 等于 周期类型级 and D3-获取执行周期时段规则(公共).关联目标内容类型编码 等于 目标))  42608

            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
            QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
            queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1784944_1_68149
            if (reqDto != null) {
                queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:1784935_1_68149
                queryConfItemMatchAnswerDetailComReqDto.setConfOptionCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784938_1_68149
            }
            if (receptionServiceRes != null) {
                queryConfItemMatchAnswerDetailComReqDto.setIsPlatData(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1784933_1_68149
            }

            /*D2-3查周期类型的周期配置标识[2486]   */
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfSchemeId(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置方案ID 不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfOptionCode(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-选项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-是否标准答案不能为空", false);
            queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getExtensionField2() == null)) {
                //if(D2-3查当前周期类型的周期配置标识.扩展字段2（非必填） 值等于空 )  71350

//异常结束 71351
                throw new BizException("220200406", "对不起，周期类型的周期配置未设置~", false);
            }
            OmsEvaCycleConf omsEvaCycleConf = null;
            if (queryConfItemMatchAnswerDetailComRespDto != null) {
                QueryCycleConfDetailReq queryCycleConfDetailReq = new QueryCycleConfDetailReq();
                queryCycleConfDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1785050_1_68150
                if (queryConfItemMatchAnswerDetailComRespDto != null) {
                    queryCycleConfDetailReq.setCycleConfCode(queryConfItemMatchAnswerDetailComRespDto.getExtensionField2());//SimpleFieldAssign//sourceId:1785048_1_68150
                }
                if (reqDto != null) {
                    queryCycleConfDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1785076_1_68150
                }

                /*3-2-08查周期配置详情[2360]   */
                Assert.isNull(queryCycleConfDetailReq.getCycleConfCode(), "D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期配置标识不能为空", false);
                Assert.isNull(queryCycleConfDetailReq.getCycleTypeCode(), "D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期类型标识不能为空", false);
                Assert.isNull(queryCycleConfDetailReq.getSubjectLifeCycle(), "D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-主体生命周期不能为空", false);
                omsEvaCycleConf = mOmsEvaCycleConfService.queryCycleConfDetail(queryCycleConfDetailReq)/*vcase invoke 本地 method 方法调用;*/;
                Assert.isTrue(omsEvaCycleConf == null || omsEvaCycleConf.getFillinTimeRuleCode() == null, "找不到数据，系统异常", false);


            }
            ObtainCycleTimeRuleInfoComRespDto obtainCycleTimeRuleInfoComRespDto_2 = null;
            if (omsEvaCycleConf != null) {
                ObtainCycleTimeRuleInfoComReqDto obtainCycleTimeRuleInfoComReqDto_1 = new ObtainCycleTimeRuleInfoComReqDto();
                if (reqDto != null && reqDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())) {
                    obtainCycleTimeRuleInfoComReqDto_1.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972791_1_42609
                }
                if (reqDto != null) {
                    obtainCycleTimeRuleInfoComReqDto_1.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:972792_1_42609
                    obtainCycleTimeRuleInfoComReqDto_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:972790_1_42609
                    obtainCycleTimeRuleInfoComReqDto_1.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784922_1_42609
                    obtainCycleTimeRuleInfoComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972793_1_42609
                }
                if (omsEvaCycleConf != null) {
                    obtainCycleTimeRuleInfoComReqDto_1.setTimeRuleCode(omsEvaCycleConf.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:1784923_1_42609
                }

                /*D3-2时段规则分析4个时间点(公共)[3519]   */
                Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getExecuteCycleStageId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-执行周期阶段ID不能为空", false);
                Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getCycleId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期ID不能为空", false);
                Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getTimeRuleCode(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-时段规则标识不能为空", false);
                Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getCycleTypeCode(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期类型标识不能为空", false);
                Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getEvaluationTemplateId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-冗余评价模板ID不能为空", false);
                obtainCycleTimeRuleInfoComRespDto_2 = cycleConfService.obtainCycleTimeRuleInfoCom(obtainCycleTimeRuleInfoComReqDto_1)/*vcase invoke isSameApp*/;


            }
//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            if (obtainCycleTimeRuleInfoComRespDto_2 != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
                if (obtainCycleTimeRuleInfoComRespDto_2 != null) {
                    receptionServiceReq_2.setTimePeriodStartTime(obtainCycleTimeRuleInfoComRespDto_2.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973015_1_42613
                    receptionServiceReq_2.setTimePeriodEndTime(obtainCycleTimeRuleInfoComRespDto_2.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973016_1_42613
                    receptionServiceReq_2.setComTimeField1(obtainCycleTimeRuleInfoComRespDto_2.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973030_1_42613
                    receptionServiceReq_2.setComTimeField2(obtainCycleTimeRuleInfoComRespDto_2.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973031_1_42613
                }

                /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getTimePeriodStartTime(), "D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段开始时间不能为空", false);
                Assert.isNull(receptionServiceReq_2.getTimePeriodEndTime(), "D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段结束时间不能为空", false);
                receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


                receptionServiceRes_3 = receptionServiceRes_4;
            }
        } else if ((reqDto != null && reqDto.getTimeRulesSetLevel() != null && reqDto.getTimeRulesSetLevel().equals("CYCLE_TYPE_LEVEL")) && (reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY") || reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
            //elseif(D3-获取执行周期时段规则(公共).时段规则设置级别 等于 周期类型级 and (D3-获取执行周期时段规则(公共).关联目标内容类型编码 等于 目标分类 or D3-获取执行周期时段规则(公共).关联目标内容类型编码 等于 指标))  71349

            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
            QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1 = new QueryConfItemMatchAnswerDetailComReqDto();
            queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1784944_1_71352
            if (reqDto != null) {
                queryConfItemMatchAnswerDetailComReqDto_1.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:1784935_1_71352
                queryConfItemMatchAnswerDetailComReqDto_1.setConfOptionCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784938_1_71352
            }
            if (receptionServiceRes != null) {
                queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1784933_1_71352
            }

            /*D2-3查周期类型的周期配置标识[2486]   */
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfSchemeId(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置方案ID 不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfOptionCode(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-选项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-是否标准答案不能为空", false);
            queryConfItemMatchAnswerDetailComRespDto_2 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((queryConfItemMatchAnswerDetailComRespDto_2 != null && queryConfItemMatchAnswerDetailComRespDto_2.getExtensionField2() != null)) {
                //if(D2-3查当前周期类型的周期配置标识.扩展字段2（非必填） 值不等于空 )  71353

                OmsEvaCycleConf omsEvaCycleConf_2 = null;
                if (queryConfItemMatchAnswerDetailComRespDto_2 != null) {
                    QueryCycleConfDetailReq queryCycleConfDetailReq_1 = new QueryCycleConfDetailReq();
                    queryCycleConfDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1785050_1_71354
                    if (queryConfItemMatchAnswerDetailComRespDto_2 != null) {
                        queryCycleConfDetailReq_1.setCycleConfCode(queryConfItemMatchAnswerDetailComRespDto_2.getExtensionField2());//SimpleFieldAssign//sourceId:1785048_1_71354
                    }
                    if (reqDto != null) {
                        queryCycleConfDetailReq_1.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1785076_1_71354
                    }

                    /*3-2-08查周期配置详情[2360]   */
                    Assert.isNull(queryCycleConfDetailReq_1.getCycleConfCode(), "D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期配置标识不能为空", false);
                    Assert.isNull(queryCycleConfDetailReq_1.getCycleTypeCode(), "D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期类型标识不能为空", false);
                    Assert.isNull(queryCycleConfDetailReq_1.getSubjectLifeCycle(), "D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-主体生命周期不能为空", false);
                    omsEvaCycleConf_2 = mOmsEvaCycleConfService.queryCycleConfDetail(queryCycleConfDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;
                    Assert.isTrue(omsEvaCycleConf_2 == null || omsEvaCycleConf_2.getFillinTimeRuleCode() == null, "找不到数据，系统异常", false);


                }
                ObtainCycleTimeRuleInfoComRespDto obtainCycleTimeRuleInfoComRespDto_3 = null;
                if (omsEvaCycleConf_2 != null) {
                    ObtainCycleTimeRuleInfoComReqDto obtainCycleTimeRuleInfoComReqDto_2 = new ObtainCycleTimeRuleInfoComReqDto();
                    if (reqDto != null && reqDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())) {
                        obtainCycleTimeRuleInfoComReqDto_2.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972791_1_71355
                    }
                    if (reqDto != null) {
                        obtainCycleTimeRuleInfoComReqDto_2.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:972792_1_71355
                        obtainCycleTimeRuleInfoComReqDto_2.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:972790_1_71355
                        obtainCycleTimeRuleInfoComReqDto_2.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784922_1_71355
                        obtainCycleTimeRuleInfoComReqDto_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972793_1_71355
                    }
                    if (omsEvaCycleConf_2 != null) {
                        obtainCycleTimeRuleInfoComReqDto_2.setTimeRuleCode(omsEvaCycleConf_2.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:1784923_1_71355
                    }

                    /*D3-2时段规则分析4个时间点(公共)[3519]   */
                    Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getExecuteCycleStageId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-执行周期阶段ID不能为空", false);
                    Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getCycleId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期ID不能为空", false);
                    Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getTimeRuleCode(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-时段规则标识不能为空", false);
                    Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getCycleTypeCode(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期类型标识不能为空", false);
                    Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getEvaluationTemplateId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-冗余评价模板ID不能为空", false);
                    obtainCycleTimeRuleInfoComRespDto_3 = cycleConfService.obtainCycleTimeRuleInfoCom(obtainCycleTimeRuleInfoComReqDto_2)/*vcase invoke isSameApp*/;


                }
//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
                if (obtainCycleTimeRuleInfoComRespDto_3 != null) {
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
                    if (obtainCycleTimeRuleInfoComRespDto_3 != null) {
                        receptionServiceReq_3.setTimePeriodStartTime(obtainCycleTimeRuleInfoComRespDto_3.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973015_1_71356
                        receptionServiceReq_3.setTimePeriodEndTime(obtainCycleTimeRuleInfoComRespDto_3.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973016_1_71356
                        receptionServiceReq_3.setComTimeField1(obtainCycleTimeRuleInfoComRespDto_3.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973030_1_71356
                        receptionServiceReq_3.setComTimeField2(obtainCycleTimeRuleInfoComRespDto_3.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973031_1_71356
                    }

                    /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_3.getTimePeriodStartTime(), "D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段开始时间不能为空", false);
                    Assert.isNull(receptionServiceReq_3.getTimePeriodEndTime(), "D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段结束时间不能为空", false);
                    receptionServiceRes_5 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


                    receptionServiceRes_3 = receptionServiceRes_5;
                }
            } else if ((queryConfItemMatchAnswerDetailComRespDto_2 != null && queryConfItemMatchAnswerDetailComRespDto_2.getExtensionField2() == null && reqDto != null && reqDto.getCycleMode() != null && reqDto.getCycleMode().equals("FATHER_SON_CYCLE")) && (reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("TRUE") || reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("TRUE"))) {
                //elseif((D2-3查周期类型的周期配置标识.扩展字段2（非必填） 值等于空  and D3-获取执行周期时段规则(公共).周期模式 等于 父子周期) and (D3-获取执行周期时段规则(公共).是否父周期 等于 是 or D3-获取执行周期时段规则(公共).是否中期 等于 是))  71357

                QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_3 = null;
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_2 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_2.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1784944_1_71358
                if (reqDto != null) {
                    queryConfItemMatchAnswerDetailComReqDto_2.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:1784935_1_71358
                    queryConfItemMatchAnswerDetailComReqDto_2.setConfOptionCode(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1784938_1_71358
                }
                if (receptionServiceRes != null) {
                    queryConfItemMatchAnswerDetailComReqDto_2.setIsPlatData(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1784933_1_71358
                }

                /*D2-3查周期类型的周期配置标识[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfSchemeId(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置方案ID 不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfItemCode(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfOptionCode(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-选项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getIsPlatData(), "D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_3 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


                if ((queryConfItemMatchAnswerDetailComRespDto_3 != null && queryConfItemMatchAnswerDetailComRespDto_3.getExtensionField2() != null)) {
                    //if(D2-3查子周期类型的周期配置标识.扩展字段2（非必填） 值不等于空 )  71361

                    OmsEvaCycleConf omsEvaCycleConf_3 = null;
                    if (queryConfItemMatchAnswerDetailComRespDto_3 != null) {
                        QueryCycleConfDetailReq queryCycleConfDetailReq_2 = new QueryCycleConfDetailReq();
                        queryCycleConfDetailReq_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1785050_1_71365
                        if (queryConfItemMatchAnswerDetailComRespDto_3 != null) {
                            queryCycleConfDetailReq_2.setCycleConfCode(queryConfItemMatchAnswerDetailComRespDto_3.getExtensionField2());//SimpleFieldAssign//sourceId:1785048_1_71365
                        }
                        if (reqDto != null) {
                            queryCycleConfDetailReq_2.setCycleTypeCode(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1785076_1_71365
                        }

                        /*3-2-08查周期配置详情[2360]   */
                        Assert.isNull(queryCycleConfDetailReq_2.getCycleConfCode(), "D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期配置标识不能为空", false);
                        Assert.isNull(queryCycleConfDetailReq_2.getCycleTypeCode(), "D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期类型标识不能为空", false);
                        Assert.isNull(queryCycleConfDetailReq_2.getSubjectLifeCycle(), "D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-主体生命周期不能为空", false);
                        omsEvaCycleConf_3 = mOmsEvaCycleConfService.queryCycleConfDetail(queryCycleConfDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;
                        Assert.isTrue(omsEvaCycleConf_3 == null || omsEvaCycleConf_3.getFillinTimeRuleCode() == null, "找不到数据，系统异常", false);


                    }
                    ObtainCycleTimeRuleInfoComRespDto obtainCycleTimeRuleInfoComRespDto_4 = null;
                    if (omsEvaCycleConf_3 != null) {
                        ObtainCycleTimeRuleInfoComReqDto obtainCycleTimeRuleInfoComReqDto_3 = new ObtainCycleTimeRuleInfoComReqDto();
                        if (reqDto != null && reqDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())) {
                            obtainCycleTimeRuleInfoComReqDto_3.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972791_1_71366
                        }
                        if (reqDto != null) {
                            obtainCycleTimeRuleInfoComReqDto_3.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:972792_1_71366
                            obtainCycleTimeRuleInfoComReqDto_3.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:972790_1_71366
                            obtainCycleTimeRuleInfoComReqDto_3.setCycleTypeCode(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1784922_1_71366
                            obtainCycleTimeRuleInfoComReqDto_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972793_1_71366
                        }
                        if (omsEvaCycleConf_3 != null) {
                            obtainCycleTimeRuleInfoComReqDto_3.setTimeRuleCode(omsEvaCycleConf_3.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:1784923_1_71366
                        }

                        /*D3-2时段规则分析4个时间点(公共)[3519]   */
                        Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getExecuteCycleStageId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-执行周期阶段ID不能为空", false);
                        Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getCycleId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期ID不能为空", false);
                        Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getTimeRuleCode(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-时段规则标识不能为空", false);
                        Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getCycleTypeCode(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期类型标识不能为空", false);
                        Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getEvaluationTemplateId(), "D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-冗余评价模板ID不能为空", false);
                        obtainCycleTimeRuleInfoComRespDto_4 = cycleConfService.obtainCycleTimeRuleInfoCom(obtainCycleTimeRuleInfoComReqDto_3)/*vcase invoke isSameApp*/;


                    }
//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
                    if (obtainCycleTimeRuleInfoComRespDto_4 != null) {
                        CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
                        if (obtainCycleTimeRuleInfoComRespDto_4 != null) {
                            receptionServiceReq_4.setTimePeriodStartTime(obtainCycleTimeRuleInfoComRespDto_4.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973015_1_71367
                            receptionServiceReq_4.setTimePeriodEndTime(obtainCycleTimeRuleInfoComRespDto_4.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973016_1_71367
                            receptionServiceReq_4.setComTimeField1(obtainCycleTimeRuleInfoComRespDto_4.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973030_1_71367
                            receptionServiceReq_4.setComTimeField2(obtainCycleTimeRuleInfoComRespDto_4.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973031_1_71367
                        }

                        /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */
                        Assert.isNull(receptionServiceReq_4.getTimePeriodStartTime(), "D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段开始时间不能为空", false);
                        Assert.isNull(receptionServiceReq_4.getTimePeriodEndTime(), "D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段结束时间不能为空", false);
                        receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_4);


                        receptionServiceRes_3 = receptionServiceRes_6;
                    }
                } else {
                    //else  71363

//异常结束 71364
                    throw new BizException("220200406", "对不起，周期类型的周期配置未设置~", false);
                }
            } else {
                //else  71359

//异常结束 71360
                throw new BizException("220200406", "对不起，周期类型的周期配置未设置~", false);
            }
        }
        ObtainExecuteCycleTimeRuleComRespDto retData = new ObtainExecuteCycleTimeRuleComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setTimePeriodStartTime(receptionServiceRes_3.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973077_1
            retData.setTimePeriodEndTime(receptionServiceRes_3.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973078_1
            retData.setFollowTimePeriodStartTime(receptionServiceRes_3.getComTimeField1());//SimpleFieldAssign//sourceId:973079_1
            retData.setFollowTimePeriodEndTime(receptionServiceRes_3.getComTimeField2());//SimpleFieldAssign//sourceId:973080_1
        }


        return retData;
    }

    /**
     * D3-获取评价模版时段规则(公共)[6904]
     * gen by moon at 5/22/2023, 4:39:10 AM
     */
    @Trace(operationName = "D3-获取评价模版时段规则(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainEvaTemplateTimeRuleComRespDto obtainEvaTemplateTimeRuleCom(ObtainEvaTemplateTimeRuleComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage 3-4-05查时段规则详情  42615
        OmsCycleTimeRule omsCycleTimeRule = null;
        QueryCycleTimeRuleDetailReq queryCycleTimeRuleDetailReq = new QueryCycleTimeRuleDetailReq();
        queryCycleTimeRuleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:973265_1_42615
        if (reqDto != null) {
            queryCycleTimeRuleDetailReq.setTimeRuleCode(reqDto.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:973250_1_42615
        }

        /*3-4-05查时段规则详情[2361]   */
        Assert.isNull(queryCycleTimeRuleDetailReq.getTimeRuleCode(), "D3-获取评价模版时段规则(公共)-3-4-05查时段规则详情-时段规则标识不能为空", false);
        Assert.isNull(queryCycleTimeRuleDetailReq.getSubjectLifeCycle(), "D3-获取评价模版时段规则(公共)-3-4-05查时段规则详情-主体生命周期不能为空", false);
        omsCycleTimeRule = mOmsCycleTimeRuleService.queryCycleTimeRuleDetail(queryCycleTimeRuleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage D3-判断执行周期是否完整(公共)  42616
        JudgeExecuteCycleStageIsIntactComRespDto judgeExecuteCycleStageIsIntactComRespDto = null;
        JudgeExecuteCycleStageIsIntactComReqDto judgeExecuteCycleStageIsIntactComReqDto = new JudgeExecuteCycleStageIsIntactComReqDto();
        if (reqDto != null) {
            judgeExecuteCycleStageIsIntactComReqDto.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:973267_1_42616
            judgeExecuteCycleStageIsIntactComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:973268_1_42616
            judgeExecuteCycleStageIsIntactComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:973269_1_42616
        }

        /*D3-判断执行周期是否完整(公共)[5465]   */
        Assert.isNull(judgeExecuteCycleStageIsIntactComReqDto.getExecuteCycleStageId(), "D3-获取评价模版时段规则(公共)-D3-判断执行周期是否完整(公共)-执行周期阶段ID不能为空", false);
        Assert.isNull(judgeExecuteCycleStageIsIntactComReqDto.getCycleId(), "D3-获取评价模版时段规则(公共)-D3-判断执行周期是否完整(公共)-周期ID不能为空", false);
        Assert.isNull(judgeExecuteCycleStageIsIntactComReqDto.getEvaluationTemplateId(), "D3-获取评价模版时段规则(公共)-D3-判断执行周期是否完整(公共)-冗余评价模板ID不能为空", false);
        judgeExecuteCycleStageIsIntactComRespDto = targetCycleService.judgeExecuteCycleStageIsIntactCom(judgeExecuteCycleStageIsIntactComReqDto)/*vcase invoke isSameApp*/;


        if ((omsCycleTimeRule != null && omsCycleTimeRule.getStartStopType() != null && omsCycleTimeRule.getStartStopType().equals("LAST_DAY_CYCLE") && judgeExecuteCycleStageIsIntactComRespDto != null && judgeExecuteCycleStageIsIntactComRespDto.getComTxtField() != null && judgeExecuteCycleStageIsIntactComRespDto.getComTxtField().equals("TRUE"))) {
            //if((3-4-05查时段规则详情.参照哪一天 等于 周期最后一天 and D3-判断执行周期是否完整(公共).执行周期是否完整 等于 是))  42618

            OmsCycle omsCycle = null;
            QueryCycleDetailReq queryCycleDetailReq = new QueryCycleDetailReq();
            queryCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:974581_1_42619
            if (reqDto != null) {
                queryCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:974580_1_42619
            }

            /*3-4-04查询周期详情[2004]   */
            Assert.isNull(queryCycleDetailReq.getCycleId(), "D3-获取评价模版时段规则(公共)-3-4-04查询周期详情-周期ID不能为空", false);
            Assert.isNull(queryCycleDetailReq.getSubjectLifeCycle(), "D3-获取评价模版时段规则(公共)-3-4-04查询周期详情-主体生命周期不能为空", false);
            omsCycle = mOmsCycleService.queryCycleDetail(queryCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: cycleShift
            ImplementCountTimeRulesTimeRespDto cycleShiftRes = null;
            if (omsCycleTimeRule != null && omsCycle != null) {
                ImplementCountTimeRulesTimeReqDto cycleShiftReq = new ImplementCountTimeRulesTimeReqDto();
                if (omsCycleTimeRule != null) {
                    cycleShiftReq.setTimeRelativeNumber(omsCycleTimeRule.getTimeRelativeNumber());//SimpleFieldAssign//sourceId:973301_1_42620
                    cycleShiftReq.setTimeNumber(omsCycleTimeRule.getTimeNumber());//SimpleFieldAssign//sourceId:973309_1_42620
                    cycleShiftReq.setFollowTimeNumber(omsCycleTimeRule.getFollowTimeNumber());//SimpleFieldAssign//sourceId:973310_1_42620
                    cycleShiftReq.setStartStopType(omsCycleTimeRule.getStartStopType());//SimpleFieldAssign//sourceId:973304_1_42620
                    cycleShiftReq.setIsContains(omsCycleTimeRule.getIsContains());//SimpleFieldAssign//sourceId:973305_1_42620
                    cycleShiftReq.setCalculateType(omsCycleTimeRule.getCalculateType());//SimpleFieldAssign//sourceId:973303_1_42620
                    cycleShiftReq.setTimeUnit(omsCycleTimeRule.getTimeUnit());//SimpleFieldAssign//sourceId:973302_1_42620
                }
                if (omsCycle != null) {
                    cycleShiftReq.setReferenceCycleTime(omsCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:973306_1_42620
                }

                /*M3执行计算时段规则时间（特殊方法）[2365]  入参时间字段，偏移数（正整数），正向偏移或反向偏移 */
                Assert.isNull(cycleShiftReq.getTimeRelativeNumber(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-相对周期提前或延后数量 不能为空", false);
                Assert.isNull(cycleShiftReq.getTimeNumber(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-时段区间数量不能为空", false);
                Assert.isNull(cycleShiftReq.getFollowTimeNumber(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-跟随时段区间数量不能为空", false);
                Assert.isNull(cycleShiftReq.getReferenceCycleTime(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-参照周期时间不能为空", false);
                Assert.isNull(cycleShiftReq.getStartStopType(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-参照哪一天不能为空", false);
                Assert.isNull(cycleShiftReq.getIsContains(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-是否包含参照这一天不能为空", false);
                Assert.isNull(cycleShiftReq.getCalculateType(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-计算类型不能为空", false);
                Assert.isNull(cycleShiftReq.getTimeUnit(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-时间单位不能为空", false);
                cycleShiftRes = nbCustomExecutionCycle.implementCountTimeRulesTime(cycleShiftReq);


            }
//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
            if (cycleShiftRes != null) {
                receptionServiceReq.setTimePeriodStartTime(cycleShiftRes.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973527_1_42621
                receptionServiceReq.setTimePeriodEndTime(cycleShiftRes.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973528_1_42621
                receptionServiceReq.setComTimeField1(cycleShiftRes.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973529_1_42621
                receptionServiceReq.setComTimeField2(cycleShiftRes.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973530_1_42621
            }

            /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */

            receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        } else if ((omsCycleTimeRule != null && omsCycleTimeRule.getStartStopType() != null && omsCycleTimeRule.getStartStopType().equals("FIRST_DAT_CYCLE") && judgeExecuteCycleStageIsIntactComRespDto != null && judgeExecuteCycleStageIsIntactComRespDto.getComTxtField() != null && judgeExecuteCycleStageIsIntactComRespDto.getComTxtField().equals("TRUE"))) {
            //elseif((3-4-05查时段规则详情.参照哪一天 等于 周期第一天 and D3-判断执行周期是否完整(公共).执行周期是否完整 等于 是))  42622

//ModelCode: getLastAndNextCycle
            ObtainGetNextCycleRespDto getLastAndNextCycleRes = null;
            ObtainGetNextCycleReqDto getLastAndNextCycleReq = new ObtainGetNextCycleReqDto();
            if (reqDto != null && reqDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())) {
                getLastAndNextCycleReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:973363_1_42623
            }
            if (reqDto != null) {
                getLastAndNextCycleReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:973365_1_42623
                getLastAndNextCycleReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:973366_1_42623
            }

            /*M3-获取获取当前周期下一个周期（特殊方法）[4754]  入参：当前时间，数据集【周期ID、周期开始时间、周期结束时间】 逻辑：根据当前时间与数据集中数据开始时间、结束时间比较，获取当前周期ID以及下一个周期ID、上一个周期ID 出参：当前周期ID、下一个周期ID、上一个周期ID */
            Assert.isNull(getLastAndNextCycleReq.getCycleId(), "D3-获取评价模版时段规则(公共)-M3-获取获取当前周期下一个周期（特殊方法）-周期ID不能为空", false);
            Assert.isNull(getLastAndNextCycleReq.getCycleTypeCode(), "D3-获取评价模版时段规则(公共)-M3-获取获取当前周期下一个周期（特殊方法）-周期类型标识不能为空", false);
            getLastAndNextCycleRes = nbCustomExecutionCycle.obtainGetNextCycle(getLastAndNextCycleReq);


            OmsCycle omsCycle_2 = null;
            QueryCycleDetailReq queryCycleDetailReq_1 = new QueryCycleDetailReq();
            queryCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:974581_1_42624
            if (getLastAndNextCycleRes != null) {
                queryCycleDetailReq_1.setCycleId(getLastAndNextCycleRes.getCycleId());//SimpleFieldAssign//sourceId:974580_1_42624
            }

            /*3-4-04查询周期详情[2004]   */
            Assert.isNull(queryCycleDetailReq_1.getCycleId(), "D3-获取评价模版时段规则(公共)-3-4-04查询周期详情-周期ID不能为空", false);
            Assert.isNull(queryCycleDetailReq_1.getSubjectLifeCycle(), "D3-获取评价模版时段规则(公共)-3-4-04查询周期详情-主体生命周期不能为空", false);
            omsCycle_2 = mOmsCycleService.queryCycleDetail(queryCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: cycleShift
            ImplementCountTimeRulesTimeRespDto cycleShiftRes_2 = null;
            if (omsCycleTimeRule != null && omsCycle_2 != null) {
                ImplementCountTimeRulesTimeReqDto cycleShiftReq_1 = new ImplementCountTimeRulesTimeReqDto();
                if (omsCycleTimeRule != null) {
                    cycleShiftReq_1.setTimeRelativeNumber(omsCycleTimeRule.getTimeRelativeNumber());//SimpleFieldAssign//sourceId:973301_1_42625
                    cycleShiftReq_1.setTimeNumber(omsCycleTimeRule.getTimeNumber());//SimpleFieldAssign//sourceId:973309_1_42625
                    cycleShiftReq_1.setFollowTimeNumber(omsCycleTimeRule.getFollowTimeNumber());//SimpleFieldAssign//sourceId:973310_1_42625
                    cycleShiftReq_1.setStartStopType(omsCycleTimeRule.getStartStopType());//SimpleFieldAssign//sourceId:973304_1_42625
                    cycleShiftReq_1.setIsContains(omsCycleTimeRule.getIsContains());//SimpleFieldAssign//sourceId:973305_1_42625
                    cycleShiftReq_1.setCalculateType(omsCycleTimeRule.getCalculateType());//SimpleFieldAssign//sourceId:973303_1_42625
                    cycleShiftReq_1.setTimeUnit(omsCycleTimeRule.getTimeUnit());//SimpleFieldAssign//sourceId:973302_1_42625
                }
                if (omsCycle_2 != null) {
                    cycleShiftReq_1.setReferenceCycleTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:973306_1_42625
                }

                /*M3执行计算时段规则时间（特殊方法）[2365]  入参时间字段，偏移数（正整数），正向偏移或反向偏移 */
                Assert.isNull(cycleShiftReq_1.getTimeRelativeNumber(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-相对周期提前或延后数量 不能为空", false);
                Assert.isNull(cycleShiftReq_1.getTimeNumber(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-时段区间数量不能为空", false);
                Assert.isNull(cycleShiftReq_1.getFollowTimeNumber(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-跟随时段区间数量不能为空", false);
                Assert.isNull(cycleShiftReq_1.getReferenceCycleTime(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-参照周期时间不能为空", false);
                Assert.isNull(cycleShiftReq_1.getStartStopType(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-参照哪一天不能为空", false);
                Assert.isNull(cycleShiftReq_1.getIsContains(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-是否包含参照这一天不能为空", false);
                Assert.isNull(cycleShiftReq_1.getCalculateType(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-计算类型不能为空", false);
                Assert.isNull(cycleShiftReq_1.getTimeUnit(), "D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-时间单位不能为空", false);
                cycleShiftRes_2 = nbCustomExecutionCycle.implementCountTimeRulesTime(cycleShiftReq_1);


            }
//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
            if (cycleShiftRes_2 != null) {
                receptionServiceReq_1.setTimePeriodStartTime(cycleShiftRes_2.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973527_1_42626
                receptionServiceReq_1.setTimePeriodEndTime(cycleShiftRes_2.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973528_1_42626
                receptionServiceReq_1.setComTimeField1(cycleShiftRes_2.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973529_1_42626
                receptionServiceReq_1.setComTimeField2(cycleShiftRes_2.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973530_1_42626
            }

            /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */

            receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


            receptionServiceRes_1 = receptionServiceRes_2;
        } else if ((judgeExecuteCycleStageIsIntactComRespDto != null && judgeExecuteCycleStageIsIntactComRespDto.getComTxtField() != null && judgeExecuteCycleStageIsIntactComRespDto.getComTxtField().equals("FALSE"))) {
            //elseif(D3-判断执行周期是否完整(公共).执行周期是否完整 等于 否)  42627

            OmsExecuteCycleStage omsExecuteCycleStage = null;
            QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
            queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:974569_1_42628
            if (reqDto != null) {
                queryExecuteCycleStageDetailReq.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:974567_1_42628
                queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:974568_1_42628
            }

            /*3-3-07查询执行周期阶段详情[2429]   */
            Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(), "D3-获取评价模版时段规则(公共)-3-3-07查询执行周期阶段详情-执行周期阶段ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3-获取评价模版时段规则(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(), "D3-获取评价模版时段规则(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空", false);
            omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
            if (omsExecuteCycleStage != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
                if (omsExecuteCycleStage != null) {
                    receptionServiceReq_2.setTimePeriodStartTime(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:973527_1_42629
                    receptionServiceReq_2.setTimePeriodEndTime(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:973528_1_42629
                    receptionServiceReq_2.setComTimeField1(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:973529_1_42629
                    receptionServiceReq_2.setComTimeField2(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:973530_1_42629
                }

                /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */

                receptionServiceRes_3 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


                receptionServiceRes_1 = receptionServiceRes_3;
            }
        }
        ObtainEvaTemplateTimeRuleComRespDto retData = new ObtainEvaTemplateTimeRuleComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setTimePeriodStartTime(receptionServiceRes_1.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:974593_1
            retData.setTimePeriodEndTime(receptionServiceRes_1.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:974594_1
            retData.setFollowTimePeriodStartTime(receptionServiceRes_1.getComTimeField1());//SimpleFieldAssign//sourceId:974595_1
            retData.setFollowTimePeriodEndTime(receptionServiceRes_1.getComTimeField2());//SimpleFieldAssign//sourceId:974596_1
        }


        return retData;
    }

    /**
     * D3-查周期类型相关配置(公共)[6948]
     * gen by moon at 5/5/2024, 7:20:48 PM
     */
    @Trace(operationName = "D3-查周期类型相关配置(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementSpecProcessCycleIsOpenComRespDto implementSpecProcessCycleIsOpenCom(ImplementSpecProcessCycleIsOpenComReqDto reqDto) {


        OmsEvaluationTemplate omsEvaluationTemplate_1 = null;
        QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_1 = null;
        QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_3 = null;
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 = null;
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_3 = null;
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_7 = null;
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_9 = null;
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
        ImplementFiveReceivingFieldRespDto receptionServiceRes_8 = null;
//virtualUsage 3-2-02查评价模板详情  43097
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:984039_1_43097
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984038_1_43097
        }

        /*3-2-02查评价模板详情[2316]   */
        Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3-查周期类型相关配置(公共)-3-2-02查评价模板详情-评价模板ID不能为空", false);
        Assert.isNull(queryEvaTempDetailReq.getIsArchive(), "D3-查周期类型相关配置(公共)-3-2-02查评价模板详情-是否存档不能为空", false);
        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationTemplate_1 = omsEvaluationTemplate;
//virtualUsage 3-3-01查目标周期模式  64992
        OmsTarget omsTarget = null;
        if (omsEvaluationTemplate != null) {
            QueryTargetDetailReq queryTargetDetailReq = new QueryTargetDetailReq();
            if (omsEvaluationTemplate != null) {
                queryTargetDetailReq.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:1654680_1_64992
                queryTargetDetailReq.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1654681_1_64992
            }

            /*3-3-01查目标周期模式[2488]   */
            Assert.isNull(queryTargetDetailReq.getTargetId(), "D3-查周期类型相关配置(公共)-3-3-01查目标周期模式-目标ID不能为空", false);
            Assert.isNull(queryTargetDetailReq.getEvaluationTemplateId(), "D3-查周期类型相关配置(公共)-3-3-01查目标周期模式-归属评价模板ID不能为空", false);
            omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        }
        if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
            //if(D3-特殊过程周期类型启用判断(公共).关联目标内容类型编码 等于 目标)  43086

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
            receptionServiceReq.setTureOrFalse("TRUE");//sourceId:984005_1_43090

            /*约定：是[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getTureOrFalse(), "D3-查周期类型相关配置(公共)-约定：是-是否不能为空", false);
            receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


            QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto = new QueryConfItemMatchAnswerListComReqDto();
                queryConfItemMatchAnswerListComReqDto.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:983670_1_43092
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerListComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:983677_1_43092
                }
                if (receptionServiceRes != null) {
                    queryConfItemMatchAnswerListComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:983673_1_43092
                }

                /*D2-3查模版启用周期类型列表[2505]   */
                Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模版启用周期类型列表-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerListComReqDto.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模版启用周期类型列表-是否标准答案不能为空", false);
                queryConfItemMatchAnswerListComRespDto = confSchemeService.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
                Assert.isTrue(queryConfItemMatchAnswerListComRespDto == null || queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList() == null || CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList()) || queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().size() == 0, "找不到数据，系统异常", false);

                queryConfItemMatchAnswerListComRespDto_1 = queryConfItemMatchAnswerListComRespDto;
            }
            QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_2 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto_1 = new QueryConfItemMatchAnswerListComReqDto();
                queryConfItemMatchAnswerListComReqDto_1.setConfItemCode("PROCESS_STAGE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:983661_1_43093
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerListComReqDto_1.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:983668_1_43093
                }
                if (receptionServiceRes != null) {
                    queryConfItemMatchAnswerListComReqDto_1.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:983664_1_43093
                }

                /*D2-3查模版启用过程周期类型[2505]   */
                Assert.isNull(queryConfItemMatchAnswerListComReqDto_1.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模版启用过程周期类型-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerListComReqDto_1.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模版启用过程周期类型-是否标准答案不能为空", false);
                queryConfItemMatchAnswerListComRespDto_2 = confSchemeService.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerListComRespDto_3 = queryConfItemMatchAnswerListComRespDto_2;
            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SUBCYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980813_1_43094
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:980824_1_43094
                }
                if (receptionServiceRes != null) {
                    queryConfItemMatchAnswerDetailComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:980822_1_43094
                }

                /*D2-3查模版子周期类型[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模版子周期类型-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模版子周期类型-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("LAST_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980798_1_43095
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerDetailComReqDto_1.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:980828_1_43095
                }
                if (receptionServiceRes != null) {
                    queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:980807_1_43095
                }

                /*D2-3查模版末级周期类型[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模版末级周期类型-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模版末级周期类型-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_2 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_2;
            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_4 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_2 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_2.setConfItemCode("SECOND_LAST_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1654633_1_64986
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerDetailComReqDto_2.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:1654644_1_64986
                }
                if (receptionServiceRes != null) {
                    queryConfItemMatchAnswerDetailComReqDto_2.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:1654642_1_64986
                }

                /*D2查第二末级周期类型配置（公共）[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2查第二末级周期类型配置（公共）-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2查第二末级周期类型配置（公共）-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_4 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_6 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_3 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_3.setConfItemCode("IS_OPEN_SPEC_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980784_1_43104
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerDetailComReqDto_3.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:980829_1_43104
                }
                if (receptionServiceRes != null) {
                    queryConfItemMatchAnswerDetailComReqDto_3.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:980793_1_43104
                }

                /*D2-3查是否开启过程特殊周期类型[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查是否开启过程特殊周期类型-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查是否开启过程特殊周期类型-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_6 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerDetailComRespDto_7 = queryConfItemMatchAnswerDetailComRespDto_6;
            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_8 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_4 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_4.setConfItemCode("TEMP_SPEC_CYCLE_TYPE_CONF");//CUSTOM_CONVENTION//sourceId:984078_1_43106
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerDetailComReqDto_4.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:984089_1_43106
                }
                if (receptionServiceRes != null) {
                    queryConfItemMatchAnswerDetailComReqDto_4.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:984087_1_43106
                }

                /*D2-3查模板启用的特殊周期类型答案[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模板启用的特殊周期类型答案-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模板启用的特殊周期类型答案-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_8 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerDetailComRespDto_9 = queryConfItemMatchAnswerDetailComRespDto_8;
            }
            QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto = null;
            if (omsEvaluationTemplate != null) {
                QueryOptionMatchResultExtendDetailComReqDto queryOptionMatchResultExtendDetailComReqDto = new QueryOptionMatchResultExtendDetailComReqDto();
                queryOptionMatchResultExtendDetailComReqDto.setEndValue("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988181_1_43295
                queryOptionMatchResultExtendDetailComReqDto.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:988171_1_43295
                if (omsEvaluationTemplate != null) {
                    queryOptionMatchResultExtendDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:988185_1_43295
                }
                if (receptionServiceRes != null) {
                    queryOptionMatchResultExtendDetailComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:988178_1_43295
                }

                /*D2-3查评价模版是否启用双周周期类型[3232]   */
                Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getEndValue(), "D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-答案值不能为空", false);
                Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-配置项标识不能为空", false);
                Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-是否标准答案不能为空", false);
                queryOptionMatchResultExtendDetailComRespDto = confSchemeService.queryOptionMatchResultExtendDetailCom(queryOptionMatchResultExtendDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((queryOptionMatchResultExtendDetailComRespDto != null && queryOptionMatchResultExtendDetailComRespDto.getOptionResultId() != null)) {
                //if(D2-3查评价模版是否启用双周周期类型.答案ID 值不等于空 )  43296

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
                if (queryOptionMatchResultExtendDetailComRespDto != null) {
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                    receptionServiceReq_1.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988573_1_43298
                    if (receptionServiceRes != null) {
                        receptionServiceReq_1.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:988358_1_43298
                    }
                    if (queryOptionMatchResultExtendDetailComRespDto != null) {
                        receptionServiceReq_1.setIsLastCycle(queryOptionMatchResultExtendDetailComRespDto.getExtensionField1());//SimpleFieldAssign//sourceId:988361_1_43298
                        receptionServiceReq_1.setCustomField(queryOptionMatchResultExtendDetailComRespDto.getExtensionField2());//SimpleFieldAssign//sourceId:988398_1_43298
                        receptionServiceReq_1.setNextCyclePeriod(queryOptionMatchResultExtendDetailComRespDto.getExtensionField3());//SimpleFieldAssign//sourceId:988362_1_43298
                    }

                    /*约定出参：双周周期类型配置[6495]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


                    receptionServiceRes_3 = receptionServiceRes_2;
                }
            } else if ((queryOptionMatchResultExtendDetailComRespDto != null && queryOptionMatchResultExtendDetailComRespDto.getOptionResultId() == null)) {
                //elseif(D2-3查评价模版是否启用双周周期类型.答案ID 值等于空 )  43297

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
                receptionServiceReq_2.setTureOrFalse("FALSE");//sourceId:984003_1_43300

                /*约定：否[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getTureOrFalse(), "D3-查周期类型相关配置(公共)-约定：否-是否不能为空", false);
                receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
                receptionServiceReq_3.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988573_1_43299
                if (receptionServiceRes_4 != null) {
                    receptionServiceReq_3.setTureOrFalse(receptionServiceRes_4.getTureOrFalse());//SimpleFieldAssign//sourceId:988358_1_43299
                }

                /*约定出参：双周周期类型配置[6495]  用于特殊方法接收上游入参。 */

                receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


                receptionServiceRes_3 = receptionServiceRes_6;
            }
//ModelCode: receptionService
            ImplementFiveReceivingFieldRespDto receptionServiceRes_7 = null;
            if (queryConfItemMatchAnswerDetailComRespDto_4 != null && omsTarget != null) {
                ImplementFiveReceivingFieldReqDto receptionServiceReq_4 = new ImplementFiveReceivingFieldReqDto();
                if (queryConfItemMatchAnswerDetailComRespDto_4 != null) {
                    receptionServiceReq_4.setSecondLastCycleType(queryConfItemMatchAnswerDetailComRespDto_4.getEndValue());//SimpleFieldAssign//sourceId:1654980_1_64993
                }
                if (omsTarget != null) {
                    receptionServiceReq_4.setPeriodicModeTypeCode(omsTarget.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1654981_1_64993
                }

                /*M3接收第二末级周期类型及周期模式类型编码[8467]  用于特殊方法接收上游入参。 */

                receptionServiceRes_7 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_4);


                receptionServiceRes_8 = receptionServiceRes_7;
            }
        } else if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY") || reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
            //elseif((D3-特殊过程周期类型启用判断(公共).关联目标内容类型编码 等于 目标分类 or D3-特殊过程周期类型启用判断(公共).关联目标内容类型编码 等于 指标))  43089

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_9 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_5 = new CalculateAcceptAboveFieldsReqDto();
            receptionServiceReq_5.setTureOrFalse("FALSE");//sourceId:984003_1_43098

            /*约定：否[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_5.getTureOrFalse(), "D3-查周期类型相关配置(公共)-约定：否-是否不能为空", false);
            receptionServiceRes_9 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_5);


            QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_4 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto_2 = new QueryConfItemMatchAnswerListComReqDto();
                queryConfItemMatchAnswerListComReqDto_2.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:983670_1_43100
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerListComReqDto_2.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983672_1_43100
                }
                if (receptionServiceRes_9 != null) {
                    queryConfItemMatchAnswerListComReqDto_2.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:983673_1_43100
                }

                /*D2-3查模版启用周期类型列表[2505]   */
                Assert.isNull(queryConfItemMatchAnswerListComReqDto_2.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模版启用周期类型列表-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerListComReqDto_2.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模版启用周期类型列表-是否标准答案不能为空", false);
                queryConfItemMatchAnswerListComRespDto_4 = confSchemeService.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;
                Assert.isTrue(queryConfItemMatchAnswerListComRespDto_4 == null || queryConfItemMatchAnswerListComRespDto_4.getConfSchemeItemResultList() == null || CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto_4.getConfSchemeItemResultList()) || queryConfItemMatchAnswerListComRespDto_4.getConfSchemeItemResultList().size() == 0, "找不到数据，系统异常", false);

                queryConfItemMatchAnswerListComRespDto_1 = queryConfItemMatchAnswerListComRespDto_4;
            }
            QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_5 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto_3 = new QueryConfItemMatchAnswerListComReqDto();
                queryConfItemMatchAnswerListComReqDto_3.setConfItemCode("PROCESS_STAGE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:983661_1_43101
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerListComReqDto_3.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983663_1_43101
                }
                if (receptionServiceRes_9 != null) {
                    queryConfItemMatchAnswerListComReqDto_3.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:983664_1_43101
                }

                /*D2-3查模版启用过程周期类型[2505]   */
                Assert.isNull(queryConfItemMatchAnswerListComReqDto_3.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模版启用过程周期类型-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerListComReqDto_3.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模版启用过程周期类型-是否标准答案不能为空", false);
                queryConfItemMatchAnswerListComRespDto_5 = confSchemeService.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerListComRespDto_3 = queryConfItemMatchAnswerListComRespDto_5;
            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_10 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_5 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_5.setConfItemCode("SUBCYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980813_1_43102
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerDetailComReqDto_5.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983679_1_43102
                }
                if (receptionServiceRes_9 != null) {
                    queryConfItemMatchAnswerDetailComReqDto_5.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:980822_1_43102
                }

                /*D2-3查模版子周期类型[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模版子周期类型-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模版子周期类型-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_10 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_5).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto_10;
            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_11 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_6 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_6.setConfItemCode("LAST_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980798_1_43103
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerDetailComReqDto_6.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983680_1_43103
                }
                if (receptionServiceRes_9 != null) {
                    queryConfItemMatchAnswerDetailComReqDto_6.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:980807_1_43103
                }

                /*D2-3查模版末级周期类型[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模版末级周期类型-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模版末级周期类型-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_11 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_6).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_11;
            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_12 = null;
            if (omsEvaluationTemplate != null) {
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_7 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_7.setConfItemCode("IS_OPEN_SPEC_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980784_1_43105
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerDetailComReqDto_7.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983678_1_43105
                }
                if (receptionServiceRes_9 != null) {
                    queryConfItemMatchAnswerDetailComReqDto_7.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:980793_1_43105
                }

                /*D2-3查是否开启过程特殊周期类型[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_7.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查是否开启过程特殊周期类型-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_7.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查是否开启过程特殊周期类型-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_12 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_7).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerDetailComRespDto_7 = queryConfItemMatchAnswerDetailComRespDto_12;
            }
            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_13 = null;
            QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_8 = new QueryConfItemMatchAnswerDetailComReqDto();
            queryConfItemMatchAnswerDetailComReqDto_8.setConfItemCode("TEMP_SPEC_CYCLE_TYPE_CONF");//CUSTOM_CONVENTION//sourceId:984078_1_43107
            if (reqDto != null) {
                queryConfItemMatchAnswerDetailComReqDto_8.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984080_1_43107
            }
            if (receptionServiceRes_9 != null) {
                queryConfItemMatchAnswerDetailComReqDto_8.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:984087_1_43107
            }

            /*D2-3查模板启用的特殊周期类型答案[2486]   */
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_8.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查模板启用的特殊周期类型答案-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_8.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查模板启用的特殊周期类型答案-是否标准答案不能为空", false);
            queryConfItemMatchAnswerDetailComRespDto_13 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_8).getData()/*vcase invoke 跨dubbo调用;*/;


            queryConfItemMatchAnswerDetailComRespDto_9 = queryConfItemMatchAnswerDetailComRespDto_13;
            QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto_2 = null;
            QueryOptionMatchResultExtendDetailComReqDto queryOptionMatchResultExtendDetailComReqDto_1 = new QueryOptionMatchResultExtendDetailComReqDto();
            queryOptionMatchResultExtendDetailComReqDto_1.setEndValue("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988181_1_43301
            queryOptionMatchResultExtendDetailComReqDto_1.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:988171_1_43301
            if (reqDto != null) {
                queryOptionMatchResultExtendDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:988173_1_43301
            }
            if (receptionServiceRes_9 != null) {
                queryOptionMatchResultExtendDetailComReqDto_1.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:988178_1_43301
            }

            /*D2-3查评价模版是否启用双周周期类型[3232]   */
            Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getEndValue(), "D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-答案值不能为空", false);
            Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getConfItemCode(), "D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-配置项标识不能为空", false);
            Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getIsPlatData(), "D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-是否标准答案不能为空", false);
            queryOptionMatchResultExtendDetailComRespDto_2 = confSchemeService.queryOptionMatchResultExtendDetailCom(queryOptionMatchResultExtendDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((queryOptionMatchResultExtendDetailComRespDto_2 != null && queryOptionMatchResultExtendDetailComRespDto_2.getOptionResultId() != null)) {
                //if(D2-3查评价模版是否启用双周周期类型.答案ID 值不等于空 )  43302

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_10 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_6 = new CalculateAcceptAboveFieldsReqDto();
                receptionServiceReq_6.setTureOrFalse("TRUE");//sourceId:984005_1_43306

                /*约定：是[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_6.getTureOrFalse(), "D3-查周期类型相关配置(公共)-约定：是-是否不能为空", false);
                receptionServiceRes_10 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_6);


//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_11 = null;
                if (queryOptionMatchResultExtendDetailComRespDto_2 != null) {
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_7 = new CalculateAcceptAboveFieldsReqDto();
                    receptionServiceReq_7.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988573_1_43305
                    if (receptionServiceRes_10 != null) {
                        receptionServiceReq_7.setTureOrFalse(receptionServiceRes_10.getTureOrFalse());//SimpleFieldAssign//sourceId:988358_1_43305
                    }
                    if (queryOptionMatchResultExtendDetailComRespDto_2 != null) {
                        receptionServiceReq_7.setIsLastCycle(queryOptionMatchResultExtendDetailComRespDto_2.getExtensionField1());//SimpleFieldAssign//sourceId:988361_1_43305
                        receptionServiceReq_7.setCustomField(queryOptionMatchResultExtendDetailComRespDto_2.getExtensionField2());//SimpleFieldAssign//sourceId:988398_1_43305
                        receptionServiceReq_7.setNextCyclePeriod(queryOptionMatchResultExtendDetailComRespDto_2.getExtensionField3());//SimpleFieldAssign//sourceId:988362_1_43305
                    }

                    /*约定出参：双周周期类型配置[6495]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_11 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_7);


                    receptionServiceRes_3 = receptionServiceRes_11;
                }
            } else if ((queryOptionMatchResultExtendDetailComRespDto_2 != null && queryOptionMatchResultExtendDetailComRespDto_2.getOptionResultId() == null)) {
                //elseif(D2-3查评价模版是否启用双周周期类型.答案ID 值等于空 )  43303

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_12 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_8 = new CalculateAcceptAboveFieldsReqDto();
                receptionServiceReq_8.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988573_1_43304
                if (receptionServiceRes_9 != null) {
                    receptionServiceReq_8.setTureOrFalse(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:988358_1_43304
                }

                /*约定出参：双周周期类型配置[6495]  用于特殊方法接收上游入参。 */

                receptionServiceRes_12 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_8);


                receptionServiceRes_3 = receptionServiceRes_12;
            }
        }
        ImplementSpecProcessCycleIsOpenComRespDto retData = new ImplementSpecProcessCycleIsOpenComRespDto();
        if (queryConfItemMatchAnswerListComRespDto_1 != null) {
            retData.setTemplateOpenCycleTypeList(//objList-to-objLists
                    queryConfItemMatchAnswerListComRespDto_1.getConfSchemeItemResultList().stream().map(item -> {
                        TemplateOpenCycleTypeDto elm = new TemplateOpenCycleTypeDto();
                        if (item != null) {
                            elm.setCycleTypeCode(item.getEndValue());//SimpleFieldAssign//sourceId:209444_2
                            elm.setIsLastCycleType(item.getExtensionField1());//SimpleFieldAssign//sourceId:209448_2
                            elm.setCycleTypeConfCode(item.getExtensionField2());//SimpleFieldAssign//sourceId:209449_2
                            elm.setNextCyclePeriod(item.getExtensionField3());//SimpleFieldAssign//sourceId:209450_2
                        }
                        return elm;
                    }).collect(Collectors.toList()));//objList-to-objLists//sourceId:984046_1
        }
        if (queryConfItemMatchAnswerListComRespDto_3 != null && queryConfItemMatchAnswerListComRespDto_3.getConfSchemeItemResultList() != null && !CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto_3.getConfSchemeItemResultList())) {
            retData.setCourseCycleTypeList(queryConfItemMatchAnswerListComRespDto_3.getConfSchemeItemResultList().stream().map(item -> item.getEndValue())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:984047_1
        }
        if (queryConfItemMatchAnswerDetailComRespDto_7 != null) {
            retData.setIsOpenSpecCycleType(queryConfItemMatchAnswerDetailComRespDto_7.getEndValue());//SimpleFieldAssign//sourceId:980811_1
        }
        if (queryConfItemMatchAnswerDetailComRespDto_9 != null) {
            retData.setTempOpenSpecialCycleType(queryConfItemMatchAnswerDetailComRespDto_9.getEndValue());//SimpleFieldAssign//sourceId:984091_1
        }
        if (receptionServiceRes_8 != null) {
            retData.setPeriodicModeTypeCode(receptionServiceRes_8.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1654992_1
            retData.setSecondLastCycleType(receptionServiceRes_8.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1654991_1
        }
        if (queryConfItemMatchAnswerDetailComRespDto_3 != null) {
            retData.setLastCycleType(queryConfItemMatchAnswerDetailComRespDto_3.getEndValue());//SimpleFieldAssign//sourceId:984044_1
        }
        if (queryConfItemMatchAnswerDetailComRespDto_1 != null) {
            retData.setSubcycleType(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:984045_1
        }
        if (omsEvaluationTemplate_1 != null) {
            retData.setTargetId(omsEvaluationTemplate_1.getTargetId());//SimpleFieldAssign//sourceId:984048_1
            retData.setEvaTempCreateTime(omsEvaluationTemplate_1.getCreateTime());//SimpleFieldAssign//sourceId:984049_1
        }
        if (receptionServiceRes_3 != null) {
            retData.setTureOrFalse(receptionServiceRes_3.getTureOrFalse());//SimpleFieldAssign//sourceId:988380_1
            retData.setCycleTypeCode(receptionServiceRes_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:988576_1
            retData.setIsLastCycle(receptionServiceRes_3.getIsLastCycle());//SimpleFieldAssign//sourceId:988381_1
            retData.setCycleTypeConfCode(receptionServiceRes_3.getCustomField());//SimpleFieldAssign//sourceId:988401_1
            retData.setNextCyclePeriod(receptionServiceRes_3.getNextCyclePeriod());//SimpleFieldAssign//sourceId:988383_1
        }


        return retData;
    }

    /**
     * D3-查询目标内容可循环周期类型(公共)[6954]
     * gen by moon at 11/21/2023, 3:23:33 PM
     */
    @Trace(operationName = "D3-查询目标内容可循环周期类型(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTargetContentNextCyclePeriodComRespDto implementTargetContentNextCyclePeriodCom(ImplementTargetContentNextCyclePeriodComReqDto reqDto) {


        QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto_1 = null;
        if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
            //if(D3-查询目标内容可循环周期类型(公共).关联目标内容类型编码 等于 目标)  43108

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
            receptionServiceReq.setTureOrFalse("TRUE");//sourceId:984484_1_43113

            /*约定：是[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getTureOrFalse(), "D3-查询目标内容可循环周期类型(公共)-约定：是-是否不能为空", false);
            receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


            OmsEvaluationTemplate omsEvaluationTemplate = null;
            QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
            queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:984316_1_43112
            if (reqDto != null) {
                queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984315_1_43112
            }

            /*3-2-02查评价模板详情[2316]   */
            Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3-查询目标内容可循环周期类型(公共)-3-2-02查评价模板详情-评价模板ID不能为空", false);
            Assert.isNull(queryEvaTempDetailReq.getIsArchive(), "D3-查询目标内容可循环周期类型(公共)-3-2-02查评价模板详情-是否存档不能为空", false);
            omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto = null;
            if (omsEvaluationTemplate != null) {
                QueryOptionMatchResultExtendDetailComReqDto queryOptionMatchResultExtendDetailComReqDto = new QueryOptionMatchResultExtendDetailComReqDto();
                queryOptionMatchResultExtendDetailComReqDto.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:984098_1_43111
                if (reqDto != null) {
                    queryOptionMatchResultExtendDetailComReqDto.setEndValue(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:984108_1_43111
                }
                if (omsEvaluationTemplate != null) {
                    queryOptionMatchResultExtendDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:984112_1_43111
                }
                if (receptionServiceRes != null) {
                    queryOptionMatchResultExtendDetailComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:984105_1_43111
                }

                /*D2-3查最近可循环周期类型[3232]   */
                Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getEndValue(), "D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-答案值不能为空", false);
                Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getConfItemCode(), "D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-配置项标识不能为空", false);
                Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getIsPlatData(), "D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-是否标准答案不能为空", false);
                queryOptionMatchResultExtendDetailComRespDto = confSchemeService.queryOptionMatchResultExtendDetailCom(queryOptionMatchResultExtendDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                queryOptionMatchResultExtendDetailComRespDto_1 = queryOptionMatchResultExtendDetailComRespDto;
            }
        } else if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY") || reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
            //elseif((D3-查询目标内容可循环周期类型(公共).关联目标内容类型编码 等于 目标分类 or D3-查询目标内容可循环周期类型(公共).关联目标内容类型编码 等于 指标))  43109

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
            receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:984654_1_43114

            /*约定：否[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getTureOrFalse(), "D3-查询目标内容可循环周期类型(公共)-约定：否-是否不能为空", false);
            receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


            QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto_2 = null;
            QueryOptionMatchResultExtendDetailComReqDto queryOptionMatchResultExtendDetailComReqDto_1 = new QueryOptionMatchResultExtendDetailComReqDto();
            queryOptionMatchResultExtendDetailComReqDto_1.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:984098_1_43110
            if (reqDto != null) {
                queryOptionMatchResultExtendDetailComReqDto_1.setEndValue(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:984108_1_43110
                queryOptionMatchResultExtendDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984100_1_43110
            }
            if (receptionServiceRes_2 != null) {
                queryOptionMatchResultExtendDetailComReqDto_1.setIsPlatData(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:984105_1_43110
            }

            /*D2-3查最近可循环周期类型[3232]   */
            Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getEndValue(), "D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-答案值不能为空", false);
            Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getConfItemCode(), "D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-配置项标识不能为空", false);
            Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getIsPlatData(), "D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-是否标准答案不能为空", false);
            queryOptionMatchResultExtendDetailComRespDto_2 = confSchemeService.queryOptionMatchResultExtendDetailCom(queryOptionMatchResultExtendDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            queryOptionMatchResultExtendDetailComRespDto_1 = queryOptionMatchResultExtendDetailComRespDto_2;
        }
        ImplementTargetContentNextCyclePeriodComRespDto retData = new ImplementTargetContentNextCyclePeriodComRespDto();
        if (queryOptionMatchResultExtendDetailComRespDto_1 != null) {
            retData.setOptionResultId(queryOptionMatchResultExtendDetailComRespDto_1.getOptionResultId());//SimpleFieldAssign//sourceId:1341862_1
            retData.setNextCyclePeriod(queryOptionMatchResultExtendDetailComRespDto_1.getExtensionField3());//SimpleFieldAssign//sourceId:984658_1
        }


        return retData;
    }

    /**
     * D3-执行时段规则配置判断(公共)[6956]
     * gen by moon at 7/6/2024, 11:54:42 PM
     */
    @Trace(operationName = "D3-执行时段规则配置判断(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTimeRuleConfComRespDto implementTimeRuleConfCom(ImplementTimeRuleConfComReqDto reqDto) {


        OmsEvaluationTemplate omsEvaluationTemplate_1 = null;
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 = null;
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_3 = null;
//virtualUsage 3-2-02查评价模板配置方案ID  71065
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:985619_1_71065
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:985588_1_71065
        }

        /*3-2-02查评价模板配置方案ID[2316]   */
        Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3-执行时段规则配置判断(公共)-3-2-02查评价模板配置方案ID-评价模板ID不能为空", false);
        Assert.isNull(queryEvaTempDetailReq.getIsArchive(), "D3-执行时段规则配置判断(公共)-3-2-02查评价模板配置方案ID-是否存档不能为空", false);
        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationTemplate_1 = omsEvaluationTemplate;

        if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
            //if(D3-执行时段规则配置判断(公共).关联目标内容类型编码 等于 目标)  43131

//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes = null;
            ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
            receptionServiceReq.setTureOrFalse("TRUE");//sourceId:985545_1_43133

            /*M3约定：是[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getTureOrFalse(), "D3-执行时段规则配置判断(公共)-M3约定：是-是否不能为空", false);
            receptionServiceRes = nbCustomExecutionCycle.implementAcceptField(receptionServiceReq);


            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
            QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
            queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TIME_RULES_SET_LEVEL");//CUSTOM_CONVENTION//sourceId:985004_1_43134
            if (omsEvaluationTemplate != null) {
                queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:985015_1_43134
            }
            if (receptionServiceRes != null) {
                queryConfItemMatchAnswerDetailComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:985013_1_43134
            }

            /*D2-3查时段规则设置级别配置答案[2486]   */
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3-执行时段规则配置判断(公共)-D2-3查时段规则设置级别配置答案-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3-执行时段规则配置判断(公共)-D2-3查时段规则设置级别配置答案-是否标准答案不能为空", false);
            queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
            if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("EVA_TEMP_LEVEL"))) {
                //if(D2-3查时段规则设置级别配置答案.答案值 等于 评价模板级)  43137

                QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("FILL_TIME_RULES_CODE");//CUSTOM_CONVENTION//sourceId:985549_1_43138
                if (omsEvaluationTemplate != null) {
                    queryConfItemMatchAnswerDetailComReqDto_1.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:985562_1_43138
                }
                if (receptionServiceRes != null) {
                    queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:985558_1_43138
                }

                /*D2-3查评价模板填报时段规则标识答案[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(), "D3-执行时段规则配置判断(公共)-D2-3查评价模板填报时段规则标识答案-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(), "D3-执行时段规则配置判断(公共)-D2-3查评价模板填报时段规则标识答案-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_2 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_2;
            }
        } else if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY") || reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
            //elseif((D3-执行时段规则配置判断(公共).关联目标内容类型编码 等于 目标分类 or D3-执行时段规则配置判断(公共).关联目标内容类型编码 等于 指标))  43132

//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
            ImplementAcceptFieldReqDto receptionServiceReq_1 = new ImplementAcceptFieldReqDto();
            receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:985547_1_43140

            /*M3约定：否[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getTureOrFalse(), "D3-执行时段规则配置判断(公共)-M3约定：否-是否不能为空", false);
            receptionServiceRes_2 = nbCustomExecutionCycle.implementAcceptField(receptionServiceReq_1);


            QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_4 = null;
            QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_2 = new QueryConfItemMatchAnswerDetailComReqDto();
            queryConfItemMatchAnswerDetailComReqDto_2.setConfItemCode("TIME_RULES_SET_LEVEL");//CUSTOM_CONVENTION//sourceId:985004_1_43139
            if (reqDto != null) {
                queryConfItemMatchAnswerDetailComReqDto_2.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:985006_1_43139
            }
            if (receptionServiceRes_2 != null) {
                queryConfItemMatchAnswerDetailComReqDto_2.setIsPlatData(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:985013_1_43139
            }

            /*D2-3查时段规则设置级别配置答案[2486]   */
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfItemCode(), "D3-执行时段规则配置判断(公共)-D2-3查时段规则设置级别配置答案-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getIsPlatData(), "D3-执行时段规则配置判断(公共)-D2-3查时段规则设置级别配置答案-是否标准答案不能为空", false);
            queryConfItemMatchAnswerDetailComRespDto_4 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


            queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto_4;
            if ((queryConfItemMatchAnswerDetailComRespDto_4 != null && queryConfItemMatchAnswerDetailComRespDto_4.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto_4.getEndValue().equals("EVA_TEMP_LEVEL"))) {
                //if(D2-3查时段规则设置级别配置答案.答案值 等于 评价模板级)  43141

                QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_5 = null;
                QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_3 = new QueryConfItemMatchAnswerDetailComReqDto();
                queryConfItemMatchAnswerDetailComReqDto_3.setConfItemCode("FILL_TIME_RULES_CODE");//CUSTOM_CONVENTION//sourceId:985549_1_43142
                if (reqDto != null) {
                    queryConfItemMatchAnswerDetailComReqDto_3.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:985551_1_43142
                }
                if (receptionServiceRes_2 != null) {
                    queryConfItemMatchAnswerDetailComReqDto_3.setIsPlatData(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:985558_1_43142
                }

                /*D2-3查评价模板填报时段规则标识答案[2486]   */
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getConfItemCode(), "D3-执行时段规则配置判断(公共)-D2-3查评价模板填报时段规则标识答案-配置项标识不能为空", false);
                Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getIsPlatData(), "D3-执行时段规则配置判断(公共)-D2-3查评价模板填报时段规则标识答案-是否标准答案不能为空", false);
                queryConfItemMatchAnswerDetailComRespDto_5 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


                queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_5;
            }
        }
        ImplementTimeRuleConfComRespDto retData = new ImplementTimeRuleConfComRespDto();
        if (omsEvaluationTemplate_1 != null) {
            retData.setConfSchemeId(omsEvaluationTemplate_1.getConfSchemeId());//SimpleFieldAssign//sourceId:1785032_1
        }
        if (queryConfItemMatchAnswerDetailComRespDto_1 != null) {
            retData.setTimeRulesSetLevel(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:985621_1
        }
        if (queryConfItemMatchAnswerDetailComRespDto_3 != null) {
            retData.setTimeRuleTypeCode(queryConfItemMatchAnswerDetailComRespDto_3.getEndValue());//SimpleFieldAssign//sourceId:985622_1
        }

        Assert.isTrue(retData == null || retData.getConfSchemeId() == null, "找不到数据，系统异常", false);


        return retData;
    }

    /**
     * D3-执行两个月内工作日范围(公共)[6972]
     * gen by moon at 5/27/2023, 5:14:24 PM
     */
    @Trace(operationName = "D3-执行两个月内工作日范围(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementWorkDaysTwoMonthsComRespDto implementWorkDaysTwoMonthsCom(ImplementWorkDaysTwoMonthsComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
        QueryWorkDaysTwoMonthsListComRespDto queryWorkDaysTwoMonthsListComRespDto_1 = null;
        if ((reqDto != null && reqDto.getCycleTypeCode() != null && reqDto.getCycleTypeCode().equals("WEEK") || reqDto != null && reqDto.getCycleTypeCode() != null && reqDto.getCycleTypeCode().equals("DOUBLE_WEEKS"))) {
            //if((D3-执行两个月内工作日范围(公共).周期类型标识 等于 周 or D3-执行两个月内工作日范围(公共).周期类型标识 等于 双周))  43226

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq.setComTimeField1(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:986954_1_43231
            }

            /*约定出参：参照时间[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getComTimeField1(), "D3-执行两个月内工作日范围(公共)-约定出参：参照时间-通用时间字段1不能为空", false);
            receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
            QueryWorkDaysTwoMonthsListComRespDto queryWorkDaysTwoMonthsListComRespDto = null;
            QueryWorkDaysTwoMonthsListComReqDto queryWorkDaysTwoMonthsListComReqDto = new QueryWorkDaysTwoMonthsListComReqDto();
            if (reqDto != null) {
                queryWorkDaysTwoMonthsListComReqDto.setComTimeField(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:986780_1_43227
            }

            /*D3查询两月内工作日列表(公共)[5348]   */
            Assert.isNull(queryWorkDaysTwoMonthsListComReqDto.getComTimeField(), "D3-执行两个月内工作日范围(公共)-D3查询两月内工作日列表(公共)-通用时间字段不能为空", false);
            queryWorkDaysTwoMonthsListComRespDto = targetCycleService.queryWorkDaysTwoMonthsListCom(queryWorkDaysTwoMonthsListComReqDto)/*vcase invoke isSameApp*/;


            queryWorkDaysTwoMonthsListComRespDto_1 = queryWorkDaysTwoMonthsListComRespDto;
        } else {
            //else  43228

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq_1.setComTimeField1(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:986954_1_43232
            }

            /*约定出参：参照时间[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getComTimeField1(), "D3-执行两个月内工作日范围(公共)-约定出参：参照时间-通用时间字段1不能为空", false);
            receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


            receptionServiceRes_1 = receptionServiceRes_2;
            QueryWorkDaysTwoMonthsListComRespDto queryWorkDaysTwoMonthsListComRespDto_2 = null;
            QueryWorkDaysTwoMonthsListComReqDto queryWorkDaysTwoMonthsListComReqDto_1 = new QueryWorkDaysTwoMonthsListComReqDto();
            if (reqDto != null) {
                queryWorkDaysTwoMonthsListComReqDto_1.setComTimeField(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:986780_1_43229
            }

            /*D3查询两月内工作日列表(公共)[5348]   */
            Assert.isNull(queryWorkDaysTwoMonthsListComReqDto_1.getComTimeField(), "D3-执行两个月内工作日范围(公共)-D3查询两月内工作日列表(公共)-通用时间字段不能为空", false);
            queryWorkDaysTwoMonthsListComRespDto_2 = targetCycleService.queryWorkDaysTwoMonthsListCom(queryWorkDaysTwoMonthsListComReqDto_1)/*vcase invoke isSameApp*/;


            queryWorkDaysTwoMonthsListComRespDto_1 = queryWorkDaysTwoMonthsListComRespDto_2;
        }
        ImplementWorkDaysTwoMonthsComRespDto retData = new ImplementWorkDaysTwoMonthsComRespDto();
        if (queryWorkDaysTwoMonthsListComRespDto_1 != null) {
            retData.setWorkDaysTwoMonthsList(queryWorkDaysTwoMonthsListComRespDto_1.getWorkDaysTwoMonthsList().stream().map(item -> BeanUtil.toBean(item, WorkDaysTwoMonthsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:986782_1
        }
        if (receptionServiceRes_1 != null) {
            retData.setComTimeField1(receptionServiceRes_1.getComTimeField1());//SimpleFieldAssign//sourceId:986956_1
        }


        return retData;
    }

    /**
     * D3-执行双周执行周期处理(公共)[6985]
     * gen by moon at 6/9/2024, 10:01:32 PM
     */
    @Trace(operationName = "D3-执行双周执行周期处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDoubleWeekExecuteCycleComRespDto implementDoubleWeekExecuteCycleCom(ImplementDoubleWeekExecuteCycleComReqDto reqDto) {


        //virtualUsage D2生成数据对象批次标识(公共)  69852
        GenerateDataObjectBatchCodeComRespDto generateDataObjectBatchCodeComRespDto = null;
        GenerateDataObjectBatchCodeComReqDto generateDataObjectBatchCodeComReqDto = new GenerateDataObjectBatchCodeComReqDto();


        /*D2生成数据对象批次标识(公共)[9404]   */

        generateDataObjectBatchCodeComRespDto = interfaceModeService.generateDataObjectBatchCodeCom(generateDataObjectBatchCodeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        //virtualUsage D3-新增双周周期(公共)  46150
        AddCreateDoubleWeekCycleComRespDto addCreateDoubleWeekCycleComRespDto = null;
        AddCreateDoubleWeekCycleComReqDto addCreateDoubleWeekCycleComReqDto = new AddCreateDoubleWeekCycleComReqDto();
        if (reqDto != null) {
            addCreateDoubleWeekCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1059096_1_46150
            addCreateDoubleWeekCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1059095_1_46150
            addCreateDoubleWeekCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1059097_1_46150
        }

        /*D3-新增双周周期(公共)[7242]   */
        Assert.isNull(addCreateDoubleWeekCycleComReqDto.getTargetCycleContentId(), "D3-执行双周执行周期处理(公共)-D3-新增双周周期(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(addCreateDoubleWeekCycleComReqDto.getTargetCycleContentTypeCode(), "D3-执行双周执行周期处理(公共)-D3-新增双周周期(公共)-关联目标内容类型编码不能为空", false);
        Assert.isNull(addCreateDoubleWeekCycleComReqDto.getEvaluationTemplateId(), "D3-执行双周执行周期处理(公共)-D3-新增双周周期(公共)-冗余评价模板ID不能为空", false);
        addCreateDoubleWeekCycleComRespDto = addCreateDoubleWeekCycleCom(addCreateDoubleWeekCycleComReqDto)/*vcase invoke 同服务,同domain*/;


        //virtualUsage D3-3查询被评对象目标周期列表(公共)  43308
        QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto = null;
        QueryEvaObjTargetCycleListComReqDto queryEvaObjTargetCycleListComReqDto = new QueryEvaObjTargetCycleListComReqDto();
        queryEvaObjTargetCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:988880_1_43308
        queryEvaObjTargetCycleListComReqDto.setEvaObjTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:988881_1_43308
        queryEvaObjTargetCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:988882_1_43308
        queryEvaObjTargetCycleListComReqDto.setTreeTypeCode("PLAN_TREE");//sourceId:988883_1_43308
        queryEvaObjTargetCycleListComReqDto.setIsSubCycle("TRUE");//sourceId:988886_1_43308
        queryEvaObjTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:988888_1_43308
        if (reqDto != null) {
            queryEvaObjTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:988885_1_43308
            queryEvaObjTargetCycleListComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:988884_1_43308
            queryEvaObjTargetCycleListComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:988887_1_43308
        }

        /*D3-3查询被评对象目标周期列表(公共)[3451]   */
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjEntityId(), "D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjTypeCode(), "D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentId(), "D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentTypeCode(), "D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-关联目标内容类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsSubCycle(), "D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-是否子周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetId(), "D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-冗余目标ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsArchive(), "D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-是否存档不能为空", false);
        queryEvaObjTargetCycleListComRespDto = targetCycleService.queryEvaObjTargetCycleListCom(queryEvaObjTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage M3子周期发牌【循环开始】  43309
        //ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes : queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList()) {

//virtualUsage D3分析子周期双周周期开始时间(公共)  69850
            AnalysisSubCycleBiweeklyStartTimeComRespDto analysisSubCycleBiweeklyStartTimeComRespDto = null;
            if (generateDataObjectBatchCodeComRespDto != null && addCreateDoubleWeekCycleComRespDto != null) {
                AnalysisSubCycleBiweeklyStartTimeComReqDto analysisSubCycleBiweeklyStartTimeComReqDto = new AnalysisSubCycleBiweeklyStartTimeComReqDto();
                analysisSubCycleBiweeklyStartTimeComReqDto.setBusinessDataObject("SUB_CYCLE_MAXIMUM_WEEK_INFO");//sourceId:1860689_1_69850
                if (generateDataObjectBatchCodeComRespDto != null) {
                    analysisSubCycleBiweeklyStartTimeComReqDto.setDataObjectBatchCode(generateDataObjectBatchCodeComRespDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1860688_1_69850
                }
                if (addCreateDoubleWeekCycleComRespDto != null) {
                    analysisSubCycleBiweeklyStartTimeComReqDto.setTargetActualStartTime(addCreateDoubleWeekCycleComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1860690_1_69850
                }
                if (circulationCollectionsRes != null) {
                    analysisSubCycleBiweeklyStartTimeComReqDto.setSubCycleTargetActualStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1860691_1_69850
                }

                /*D3分析子周期双周周期开始时间(公共)[9772]   */
                Assert.isNull(analysisSubCycleBiweeklyStartTimeComReqDto.getBusinessDataObject(), "D3-执行双周执行周期处理(公共)-D3分析子周期双周周期开始时间(公共)-业务数据对象不能为空", false);
                Assert.isNull(analysisSubCycleBiweeklyStartTimeComReqDto.getDataObjectBatchCode(), "D3-执行双周执行周期处理(公共)-D3分析子周期双周周期开始时间(公共)-数据对象批次标识不能为空", false);
                Assert.isNull(analysisSubCycleBiweeklyStartTimeComReqDto.getTargetActualStartTime(), "D3-执行双周执行周期处理(公共)-D3分析子周期双周周期开始时间(公共)-父周期成果汇报时间不能为空", false);
                Assert.isNull(analysisSubCycleBiweeklyStartTimeComReqDto.getSubCycleTargetActualStartTime(), "D3-执行双周执行周期处理(公共)-D3分析子周期双周周期开始时间(公共)-子周期成果汇报开始时间不能为空", false);
                analysisSubCycleBiweeklyStartTimeComRespDto = analysisSubCycleBiweeklyStartTimeCom(analysisSubCycleBiweeklyStartTimeComReqDto)/*vcase invoke 同服务,同domain*/;


            }
//virtualUsage D2-根据开始时间结束时间计算双周(公共)  43312
            ImplementCalcDoubleWeekByTimeRangeComRespDto implementCalcDoubleWeekByTimeRangeComRespDto = null;
            if (analysisSubCycleBiweeklyStartTimeComRespDto != null) {
                ImplementCalcDoubleWeekByTimeRangeComReqDto implementCalcDoubleWeekByTimeRangeComReqDto = new ImplementCalcDoubleWeekByTimeRangeComReqDto();
                implementCalcDoubleWeekByTimeRangeComReqDto.setCycleIsCutHeadAndTail("FALSE");//sourceId:1059099_1_43312
                if (analysisSubCycleBiweeklyStartTimeComRespDto != null) {
                    implementCalcDoubleWeekByTimeRangeComReqDto.setComTimeField(analysisSubCycleBiweeklyStartTimeComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:988801_1_43312
                }
                if (circulationCollectionsRes != null) {
                    implementCalcDoubleWeekByTimeRangeComReqDto.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:988802_1_43312
                    implementCalcDoubleWeekByTimeRangeComReqDto.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:988803_1_43312
                }

                /*D2-根据开始时间结束时间计算双周(公共)[6978]   */
                Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getComTimeField(), "D3-执行双周执行周期处理(公共)-D2-根据开始时间结束时间计算双周(公共)-双周起始第一天不能为空", false);
                Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleIsCutHeadAndTail(), "D3-执行双周执行周期处理(公共)-D2-根据开始时间结束时间计算双周(公共)-周期是否裁剪头尾不能为空", false);
                Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleStartTime(), "D3-执行双周执行周期处理(公共)-D2-根据开始时间结束时间计算双周(公共)-周期开始时间不能为空", false);
                Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleEndTime(), "D3-执行双周执行周期处理(公共)-D2-根据开始时间结束时间计算双周(公共)-周期结束时间不能为空", false);
                implementCalcDoubleWeekByTimeRangeComRespDto = interfaceModeService.implementCalcDoubleWeekByTimeRangeCom(implementCalcDoubleWeekByTimeRangeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
//virtualUsage D3执行子周期最大双周推内存(公共)  69844
            ImplementSubCycleBigDubbleWeeksMemoryComRespDto implementSubCycleBigDubbleWeeksMemoryComRespDto = null;
            if (generateDataObjectBatchCodeComRespDto != null && implementCalcDoubleWeekByTimeRangeComRespDto != null) {
                ImplementSubCycleBigDubbleWeeksMemoryComReqDto implementSubCycleBigDubbleWeeksMemoryComReqDto = new ImplementSubCycleBigDubbleWeeksMemoryComReqDto();
                implementSubCycleBigDubbleWeeksMemoryComReqDto.setBusinessDataObject("SUB_CYCLE_MAXIMUM_WEEK_INFO");//sourceId:1860680_1_69844
                if (generateDataObjectBatchCodeComRespDto != null) {
                    implementSubCycleBigDubbleWeeksMemoryComReqDto.setDataObjectBatchCode(generateDataObjectBatchCodeComRespDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1860678_1_69844
                }
                if (circulationCollectionsRes != null) {
                    implementSubCycleBigDubbleWeeksMemoryComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1860679_1_69844
                }
                if (implementCalcDoubleWeekByTimeRangeComRespDto != null && implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList() != null && !CollectionUtil.isEmpty(implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList())) {
                    QueryEvaObjTargetCycleListComRespDto finalQueryEvaObjTargetCycleListComRespDto = queryEvaObjTargetCycleListComRespDto;
                    implementSubCycleBigDubbleWeeksMemoryComReqDto.setCycleList(//objList-to-objLists
                            implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList().stream().map(item -> {
                                CycleDto elm = new CycleDto();
                                if (item != null) {
                                    elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:372707_2_69844
                                    elm.setCycleStartTime(item.getCycleStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:372705_2_69844
                                    elm.setCycleEndTime(item.getCycleEndTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:372706_2_69844
                                }

                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1860677_1_69844
                }

                /*D3执行子周期最大双周推内存(公共)[9771]   */
                Assert.isNull(implementSubCycleBigDubbleWeeksMemoryComReqDto.getBusinessDataObject(), "D3-执行双周执行周期处理(公共)-D3执行子周期最大双周推内存(公共)-业务数据对象不能为空", false);
                Assert.isNull(implementSubCycleBigDubbleWeeksMemoryComReqDto.getDataObjectBatchCode(), "D3-执行双周执行周期处理(公共)-D3执行子周期最大双周推内存(公共)-数据对象批次标识不能为空", false);
                Assert.isNull(implementSubCycleBigDubbleWeeksMemoryComReqDto.getEvaObjTargetCycleId(), "D3-执行双周执行周期处理(公共)-D3执行子周期最大双周推内存(公共)-被评对象目标周期ID不能为空", false);
                implementSubCycleBigDubbleWeeksMemoryComRespDto = implementSubCycleBigDubbleWeeksMemoryCom(implementSubCycleBigDubbleWeeksMemoryComReqDto)/*vcase invoke 同服务,同domain*/;


            }
            if ((implementCalcDoubleWeekByTimeRangeComRespDto != null && implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList() != null && implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList().size() > 0)) {
                //if(D2-根据开始时间结束时间计算双周周期名称.双周周期列表数据集条数 大于 0)  43313

//ModelCode: circulationCollections
                for (DoubleWeekDto circulationCollectionsRes_2 : implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList()) {

                    OmsCycle omsCycle = null;
                    QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq = new QueryTimeRangeFindCycleDetailReq();
                    queryTimeRangeFindCycleDetailReq.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:1059107_1_46154
                    queryTimeRangeFindCycleDetailReq.setPlatformData("TRUE");//sourceId:1059108_1_46154
                    queryTimeRangeFindCycleDetailReq.setIsArchive("FALSE");//sourceId:1059110_1_46154
                    if (circulationCollectionsRes_2 != null) {
                        queryTimeRangeFindCycleDetailReq.setCycleStartTime(circulationCollectionsRes_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1059105_1_46154
                        queryTimeRangeFindCycleDetailReq.setCycleEndTime(circulationCollectionsRes_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1059106_1_46154
                    }

                    /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
                    Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(), "D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空", false);
                    Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(), "D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空", false);
                    Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(), "D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空", false);
                    Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(), "D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空", false);
                    Assert.isNull(queryTimeRangeFindCycleDetailReq.getIsArchive(), "D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否存档不能为空", false);
                    omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
                    Assert.isTrue(omsCycle == null || omsCycle.getCycleId() == null, "找不到数据，系统异常", false);


                    OmsExecuteCycleStage omsExecuteCycleStage = null;
                    if (omsCycle != null) {
                        QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
                        queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:989094_1_43337
                        if (omsCycle != null) {
                            queryExecuteCycleStageDetailReq.setCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:1059119_1_43337
                        }
                        if (circulationCollectionsRes != null) {
                            queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1816439_1_43337
                        }
                        if (reqDto != null) {
                            queryExecuteCycleStageDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:989093_1_43337
                            queryExecuteCycleStageDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:989096_1_43337
                            queryExecuteCycleStageDetailReq.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:989095_1_43337
                            queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:989097_1_43337
                        }

                        /*3-3-07查询执行周期阶段详情[2429]   */
                        Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(), "D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空", false);
                        Assert.isNull(queryExecuteCycleStageDetailReq.getCycleTypeCode(), "D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-周期类型标识不能为空", false);
                        Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(), "D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-关联目标内容ID不能为空", false);
                        Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentTypeCode(), "D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-关联目标内容类型编码不能为空", false);
                        Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(), "D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空", false);
                        Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                        omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    if ((omsExecuteCycleStage == null)) {
                        //if(3-3-07查双周执行周期阶段ID是否存在.出参 值等于空 )  43318

                        String string = null;
                        if (omsCycle != null) {
                            OmsExecuteCycleStage omsExecuteCycleStage_2 = new OmsExecuteCycleStage();
                            omsExecuteCycleStage_2.setIsFatherCycle("FALSE");//sourceId:988844_1_43357
                            omsExecuteCycleStage_2.setIsMetaphase("FALSE");//sourceId:988846_1_43357
                            omsExecuteCycleStage_2.setIsSubCycle("FALSE");//sourceId:988845_1_43357
                            omsExecuteCycleStage_2.setIsProcessCycleStage("TRUE");//sourceId:988847_1_43357
                            omsExecuteCycleStage_2.setIsStartCycle("FALSE");//sourceId:988852_1_43357
                            omsExecuteCycleStage_2.setIsEndCycle("FALSE");//sourceId:988853_1_43357
                            omsExecuteCycleStage_2.setIsCurrentCycle("FALSE");//sourceId:988867_1_43357
                            omsExecuteCycleStage_2.setIsNextCycle("FALSE");//sourceId:988868_1_43357
                            if (circulationCollectionsRes != null) {
                                omsExecuteCycleStage_2.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:988869_1_43357
                            }
                            if (omsCycle != null) {
                                omsExecuteCycleStage_2.setCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:988841_1_43357
                                omsExecuteCycleStage_2.setCycleTypeInstanceCode(omsCycle.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1603018_1_43357
                            }
                            if (circulationCollectionsRes_2 != null) {
                                omsExecuteCycleStage_2.setCycleStandardName(circulationCollectionsRes_2.getCycleStandardName());//SimpleFieldAssign//sourceId:988862_1_43357
                                omsExecuteCycleStage_2.setCycleStartTime(circulationCollectionsRes_2.getCycleStartTime());//SimpleFieldAssign//sourceId:988863_1_43357
                                omsExecuteCycleStage_2.setCycleEndTime(circulationCollectionsRes_2.getCycleEndTime());//SimpleFieldAssign//sourceId:988864_1_43357
                                omsExecuteCycleStage_2.setFillStartTime(circulationCollectionsRes_2.getCycleStartTime());//SimpleFieldAssign//sourceId:988857_1_43357
                                omsExecuteCycleStage_2.setFillEndtTime(circulationCollectionsRes_2.getCycleEndTime());//SimpleFieldAssign//sourceId:988858_1_43357
                                omsExecuteCycleStage_2.setEvaluateStartTime(circulationCollectionsRes_2.getCycleStartTime());//SimpleFieldAssign//sourceId:991119_1_43357
                                omsExecuteCycleStage_2.setEvaluateEndtTime(circulationCollectionsRes_2.getCycleEndTime());//SimpleFieldAssign//sourceId:991120_1_43357
                                omsExecuteCycleStage_2.setCycleTypeCode(circulationCollectionsRes_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:988865_1_43357
                                omsExecuteCycleStage_2.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:988843_1_43357
                            }
                            if (reqDto != null) {
                                omsExecuteCycleStage_2.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:988854_1_43357
                                omsExecuteCycleStage_2.setNextCyclePeriod(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:988870_1_43357
                                omsExecuteCycleStage_2.setEvaTempCreateTime(reqDto.getSortCreateTime());//SimpleFieldAssign//sourceId:988842_1_43357
                                omsExecuteCycleStage_2.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:988848_1_43357
                                omsExecuteCycleStage_2.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:988850_1_43357
                                omsExecuteCycleStage_2.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:988849_1_43357
                                omsExecuteCycleStage_2.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:988856_1_43357
                                omsExecuteCycleStage_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:988851_1_43357
                            }

                            /*3-3-07新增执行周期阶段[2354]   */
                            Assert.isNull(omsExecuteCycleStage_2.getEvaObjTargetCycleId(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getCycleId(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getCycleStandardName(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期名称不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getCycleStartTime(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getCycleEndTime(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getFillStartTime(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getFillEndtTime(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getCycleTypeCode(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsLastCycle(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getEvaTempCreateTime(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getOrderNumber(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期排序不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsFatherCycle(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否父周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsMetaphase(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否中期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsSubCycle(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否子周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsProcessCycleStage(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsDefinedExecuteCycleStage(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getRelateContentId(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getRelateContentTypeCode(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getTargetId(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getEvaluationTemplateId(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsStartCycle(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否开始子周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsEndCycle(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否截止子周期不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsCurrentCycle(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否末级/子周期当前不能为空", false);
                            Assert.isNull(omsExecuteCycleStage_2.getIsNextCycle(), "D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否末级/子周期下一个不能为空", false);
                            string = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    }
//ModelCode: circulationEnd
                }

            }
//virtualUsage M3-执行【循环结束】  43310
            //ModelCode: circulationEnd
        }

        ImplementDoubleWeekExecuteCycleComRespDto retData = new ImplementDoubleWeekExecuteCycleComRespDto();


        return retData;
    }

    /**
     * D3撤销修订自定义执行周期处理(公共)[7059]
     * gen by moon at 5/31/2023, 8:19:24 PM
     */
    @Trace(operationName = "D3撤销修订自定义执行周期处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UndoReviseCustomExecuteCycleDisposeComRespDto undoReviseCustomExecuteCycleDisposeCom(UndoReviseCustomExecuteCycleDisposeComReqDto reqDto) {


        //步骤0: 3-3-07-批量查询执行周期阶段列表By目标周期ID - batchQueryExecuteCycleStageListByTargetCycleIds
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
        BatchQueryExecuteCycleStageListByTargetCycleIdsReq batchQueryExecuteCycleStageListByTargetCycleIdsReq = new BatchQueryExecuteCycleStageListByTargetCycleIdsReq();
        batchQueryExecuteCycleStageListByTargetCycleIdsReq.setIsDefinedExecuteCycleStage("TRUE");//sourceId:998876_1
        if (reqDto != null) {
            batchQueryExecuteCycleStageListByTargetCycleIdsReq.setEvaObjTargetCycleList(reqDto.getExecuteCycleStageList());//list-field-assign//sourceId:998875_1
            batchQueryExecuteCycleStageListByTargetCycleIdsReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:998877_1
        }

        /*3-3-07-批量查询执行周期阶段列表By目标周期ID[6508]   */
        Assert.isNull(batchQueryExecuteCycleStageListByTargetCycleIdsReq.getIsDefinedExecuteCycleStage(), "D3撤销修订自定义执行周期处理(公共)-3-3-07-批量查询执行周期阶段列表By目标周期ID-是否自定义执行周期阶段不能为空", false);
        Assert.isNull(batchQueryExecuteCycleStageListByTargetCycleIdsReq.getEvaluationTemplateId(), "D3撤销修订自定义执行周期处理(公共)-3-3-07-批量查询执行周期阶段列表By目标周期ID-评价模板ID不能为空", false);
        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.batchQueryExecuteCycleStageListByTargetCycleIds(batchQueryExecuteCycleStageListByTargetCycleIdsReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-3-07批量删执行周期阶段 - batchDeleteExecuteCycleStage
        boolean bOOLEAN;
        if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
            List<String> listString = new ArrayList<>();
            if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                listString = listOmsExecuteCycleStage.stream().map(item -> item.getExecuteCycleStageId())
                        .collect(Collectors.toList());/*list-to-strings*///sourceId:998861_1
            }

            /*3-3-07批量删执行周期阶段[2743]   */

            bOOLEAN = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;


        }

        UndoReviseCustomExecuteCycleDisposeComRespDto retData = new UndoReviseCustomExecuteCycleDisposeComRespDto();


        return retData;
    }

    /**
     * D3-新增双周周期(公共)[7242]
     * gen by moon at 6/9/2024, 4:34:12 PM
     */
    @Trace(operationName = "D3-新增双周周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddCreateDoubleWeekCycleComRespDto addCreateDoubleWeekCycleCom(AddCreateDoubleWeekCycleComReqDto reqDto) {


        QueryEvaObjTargetCycleDetailComRespDto queryEvaObjTargetCycleDetailComRespDto_1 = null;
        //virtualUsage D3-3查询被评对象目标周期详情(公共)  46128
        QueryEvaObjTargetCycleDetailComRespDto queryEvaObjTargetCycleDetailComRespDto = null;
        QueryEvaObjTargetCycleDetailComReqDto queryEvaObjTargetCycleDetailComReqDto = new QueryEvaObjTargetCycleDetailComReqDto();
        queryEvaObjTargetCycleDetailComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1058850_1_46128
        queryEvaObjTargetCycleDetailComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1058852_1_46128
        queryEvaObjTargetCycleDetailComReqDto.setIsParentCycle("TRUE");//sourceId:1058856_1_46128
        queryEvaObjTargetCycleDetailComReqDto.setIsArchive("FALSE");//sourceId:1059072_1_46128
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1058855_1_46128
            queryEvaObjTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1058857_1_46128
        }

        /*D3-3查询被评对象目标周期详情(公共)[3489]   */
        Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaObjEntityId(), "D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaObjTypeCode(), "D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getTargetCycleContentId(), "D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getIsParentCycle(), "D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-是否父周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaluationTemplateId(), "D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getIsArchive(), "D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-是否存档不能为空", false);
        queryEvaObjTargetCycleDetailComRespDto = targetCycleService.queryEvaObjTargetCycleDetailCom(queryEvaObjTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;


        queryEvaObjTargetCycleDetailComRespDto_1 = queryEvaObjTargetCycleDetailComRespDto;
//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  46129
        OmsCycle omsCycle = null;
        if (queryEvaObjTargetCycleDetailComRespDto != null) {
            QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq = new QueryTimeRangeFindCycleDetailReq();
            queryTimeRangeFindCycleDetailReq.setCycleTypeCode("WEEK");//CUSTOM_CONVENTION//sourceId:1058828_1_46129
            queryTimeRangeFindCycleDetailReq.setPlatformData("TRUE");//sourceId:1058829_1_46129
            queryTimeRangeFindCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1058830_1_46129
            if (queryEvaObjTargetCycleDetailComRespDto != null) {
                queryTimeRangeFindCycleDetailReq.setCycleStartTime(queryEvaObjTargetCycleDetailComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1058826_1_46129
                queryTimeRangeFindCycleDetailReq.setCycleEndTime(queryEvaObjTargetCycleDetailComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1058827_1_46129
            }

            /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(), "D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(), "D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(), "D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(), "D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getSubjectLifeCycle(), "D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-主体生命周期不能为空", false);
            omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        }
//virtualUsage D2-根据开始时间结束时间计算双周(公共)  46130
        ImplementCalcDoubleWeekByTimeRangeComRespDto implementCalcDoubleWeekByTimeRangeComRespDto = null;
        if (omsCycle != null && queryEvaObjTargetCycleDetailComRespDto != null) {
            ImplementCalcDoubleWeekByTimeRangeComReqDto implementCalcDoubleWeekByTimeRangeComReqDto = new ImplementCalcDoubleWeekByTimeRangeComReqDto();
            implementCalcDoubleWeekByTimeRangeComReqDto.setCycleIsCutHeadAndTail("FALSE");//sourceId:1058841_1_46130
            if (omsCycle != null) {
                implementCalcDoubleWeekByTimeRangeComReqDto.setComTimeField(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1058837_1_46130
            }
            if (queryEvaObjTargetCycleDetailComRespDto != null) {
                implementCalcDoubleWeekByTimeRangeComReqDto.setCycleStartTime(queryEvaObjTargetCycleDetailComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1058838_1_46130
                implementCalcDoubleWeekByTimeRangeComReqDto.setCycleEndTime(queryEvaObjTargetCycleDetailComRespDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1058839_1_46130
            }

            /*D2-根据开始时间结束时间计算双周(公共)[6978]   */
            Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getComTimeField(), "D3-新增双周周期(公共)-D2-根据开始时间结束时间计算双周(公共)-双周起始第一天不能为空", false);
            Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleIsCutHeadAndTail(), "D3-新增双周周期(公共)-D2-根据开始时间结束时间计算双周(公共)-周期是否裁剪头尾不能为空", false);
            Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleStartTime(), "D3-新增双周周期(公共)-D2-根据开始时间结束时间计算双周(公共)-周期开始时间不能为空", false);
            Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleEndTime(), "D3-新增双周周期(公共)-D2-根据开始时间结束时间计算双周(公共)-周期结束时间不能为空", false);
            implementCalcDoubleWeekByTimeRangeComRespDto = interfaceModeService.implementCalcDoubleWeekByTimeRangeCom(implementCalcDoubleWeekByTimeRangeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((implementCalcDoubleWeekByTimeRangeComRespDto != null && implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList() != null && implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList().size() > 0)) {
            //if(D2-根据开始时间结束时间计算双周(公共).双周周期列表数据集条数 大于 0)  46131

//ModelCode: circulationCollections
            for (DoubleWeekDto circulationCollectionsRes : implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList()) {

                OmsCycle omsCycle_2 = null;
                QueryTimeEqualQueryCycleDetailsDetailReq queryTimeEqualQueryCycleDetailsDetailReq = new QueryTimeEqualQueryCycleDetailsDetailReq();
                queryTimeEqualQueryCycleDetailsDetailReq.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:1058732_1_46134
                queryTimeEqualQueryCycleDetailsDetailReq.setPlatformData("TRUE");//sourceId:1058734_1_46134
                queryTimeEqualQueryCycleDetailsDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1058735_1_46134
                if (circulationCollectionsRes != null) {
                    queryTimeEqualQueryCycleDetailsDetailReq.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1058730_1_46134
                    queryTimeEqualQueryCycleDetailsDetailReq.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1058731_1_46134
                }

                /*3-4-04查询时间等于查周期详情详情[5379]   */
                Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getCycleStartTime(), "D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-周期开始时间不能为空", false);
                Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getCycleEndTime(), "D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-周期结束时间不能为空", false);
                Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getCycleTypeCode(), "D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-周期类型标识不能为空", false);
                Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getPlatformData(), "D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-是否是平台不能为空", false);
                Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getSubjectLifeCycle(), "D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-主体生命周期不能为空", false);
                omsCycle_2 = mOmsCycleService.queryTimeEqualQueryCycleDetailsDetail(queryTimeEqualQueryCycleDetailsDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((omsCycle_2 == null)) {
                    //if(3-4-04查询周期是否存在.出参 值等于空 )  46135

                    GenerateTimeCycleEtcSemanticInstanceComRespDto generateTimeCycleEtcSemanticInstanceComRespDto = null;
                    GenerateTimeCycleEtcSemanticInstanceComReqDto generateTimeCycleEtcSemanticInstanceComReqDto = new GenerateTimeCycleEtcSemanticInstanceComReqDto();
                    generateTimeCycleEtcSemanticInstanceComReqDto.setTemplateSemanticEngineCode("GENERATE_IRREGULAR_CYCLE_NAME");//CUSTOM_CONVENTION//sourceId:1058747_1_46136
                    if (circulationCollectionsRes != null) {
                        generateTimeCycleEtcSemanticInstanceComReqDto.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1058753_1_46136
                        generateTimeCycleEtcSemanticInstanceComReqDto.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1058754_1_46136
                    }

                    /*D2生成时间周期等语义内容服务(公共)[5030]   */
                    Assert.isNull(generateTimeCycleEtcSemanticInstanceComReqDto.getTemplateSemanticEngineCode(), "D3-新增双周周期(公共)-D2生成时间周期等语义内容服务(公共)-模板引擎标识不能为空", false);
                    Assert.isNull(generateTimeCycleEtcSemanticInstanceComReqDto.getCycleStartTime(), "D3-新增双周周期(公共)-D2生成时间周期等语义内容服务(公共)-周期开始时间不能为空", false);
                    Assert.isNull(generateTimeCycleEtcSemanticInstanceComReqDto.getCycleEndTime(), "D3-新增双周周期(公共)-D2生成时间周期等语义内容服务(公共)-周期结束时间不能为空", false);
                    generateTimeCycleEtcSemanticInstanceComRespDto = fwCompTemplateEngineClient.generateTimeCycleEtcSemanticInstanceCom(generateTimeCycleEtcSemanticInstanceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                    String string = null;
                    if (generateTimeCycleEtcSemanticInstanceComRespDto != null) {
                        OmsCycle omsCycle_4 = new OmsCycle();
                        omsCycle_4.setCycleTypeName("双周");//CUSTOM_CONVENTION//sourceId:1058777_1_46137
                        omsCycle_4.setCycleSystemCode("YEAR");//sourceId:1058772_1_46137
                        omsCycle_4.setCycleTypeStandard("CUSTOM_STANDARD");//sourceId:1058773_1_46137
                        omsCycle_4.setPlatformData("TRUE");//sourceId:1058774_1_46137
                        omsCycle_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1058775_1_46137
                        if (generateTimeCycleEtcSemanticInstanceComRespDto != null) {
                            omsCycle_4.setCycleStandardName(generateTimeCycleEtcSemanticInstanceComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1058768_1_46137
                        }
                        if (circulationCollectionsRes != null) {
                            omsCycle_4.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1058769_1_46137
                            omsCycle_4.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1058770_1_46137
                            omsCycle_4.setCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:1058771_1_46137
                            omsCycle_4.setOrderNumber(circulationCollectionsRes.getOrderNumber());//SimpleFieldAssign//sourceId:1058778_1_46137
                        }

                        /*3-4-04新增周期[2001]   */
                        Assert.isNull(omsCycle_4.getCycleStandardName(), "D3-新增双周周期(公共)-3-4-04新增周期-周期名称不能为空", false);
                        Assert.isNull(omsCycle_4.getCycleStartTime(), "D3-新增双周周期(公共)-3-4-04新增周期-周期开始时间不能为空", false);
                        Assert.isNull(omsCycle_4.getCycleEndTime(), "D3-新增双周周期(公共)-3-4-04新增周期-周期结束时间不能为空", false);
                        Assert.isNull(omsCycle_4.getCycleTypeCode(), "D3-新增双周周期(公共)-3-4-04新增周期-周期类型标识不能为空", false);
                        Assert.isNull(omsCycle_4.getCycleTypeName(), "D3-新增双周周期(公共)-3-4-04新增周期-周期类型名称不能为空", false);
                        Assert.isNull(omsCycle_4.getOrderNumber(), "D3-新增双周周期(公共)-3-4-04新增周期-排序不能为空", false);
                        Assert.isNull(omsCycle_4.getCycleSystemCode(), "D3-新增双周周期(公共)-3-4-04新增周期-周期体系类型标识不能为空", false);
                        Assert.isNull(omsCycle_4.getCycleTypeStandard(), "D3-新增双周周期(公共)-3-4-04新增周期-冗余周期类型标准化不能为空", false);
                        Assert.isNull(omsCycle_4.getPlatformData(), "D3-新增双周周期(公共)-3-4-04新增周期-是否是平台不能为空", false);
                        Assert.isNull(omsCycle_4.getSubjectLifeCycle(), "D3-新增双周周期(公共)-3-4-04新增周期-主体生命周期不能为空", false);
                        string = mOmsCycleService.addCycle(omsCycle_4)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
//ModelCode: circulationEnd
            }

        }
        AddCreateDoubleWeekCycleComRespDto retData = new AddCreateDoubleWeekCycleComRespDto();
        if (queryEvaObjTargetCycleDetailComRespDto_1 != null) {
            retData.setTargetActualStartTime(queryEvaObjTargetCycleDetailComRespDto_1.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1860696_1
        }


        return retData;
    }

    /**
     * D3-查询执行周期对应目标周期详情(公共)[7299]
     * gen by moon at 10/1/2023, 12:28:10 PM
     */
    @Trace(operationName = "D3-查询执行周期对应目标周期详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryLastTargetCycleDetailComRespDto queryLastTargetCycleDetailCom(QueryLastTargetCycleDetailComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getIsProcessCycleStage() != null && reqDto.getIsProcessCycleStage().equals("FALSE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("TRUE"))) {
            //if((D3-查询执行周期对应目标周期详情(公共).是否过程周期阶段 等于 否 and D3-查询执行周期对应目标周期详情(公共).是否子周期 等于 是))  47674

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setIsSubCycle("TRUE");//sourceId:1088844_1_47678
            queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1088850_1_47678
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1088839_1_47678
                queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1088840_1_47678
                queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1088841_1_47678
                queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1088842_1_47678
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1088849_1_47678
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsSubCycle(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-是否子周期不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            if (omsEvaluationObjectTargetCycle != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
                if (omsEvaluationObjectTargetCycle != null) {
                    receptionServiceReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1089104_1_47679
                }

                /*约定出参：目标周期ID[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(), "D3-查询执行周期对应目标周期详情(公共)-约定出参：目标周期ID-被评对象目标周期ID不能为空", false);
                receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getIsProcessCycleStage() != null && reqDto.getIsProcessCycleStage().equals("TRUE"))) {
            //elseif(D3-查询执行周期对应目标周期详情(公共).是否过程周期阶段 等于 是)  47675

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq_1.setIsSubCycle("TRUE");//sourceId:1088844_1_47680
            queryEvaObjTargetCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1088850_1_47680
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1088839_1_47680
                queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1088840_1_47680
                queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1088841_1_47680
                queryEvaObjTargetCycleDetailReq_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1088846_1_47680
                queryEvaObjTargetCycleDetailReq_1.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1088847_1_47680
                queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1088849_1_47680
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsSubCycle(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-是否子周期不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getSubjectLifeCycle(), "D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空", false);
            omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            if (omsEvaluationObjectTargetCycle_2 != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                if (omsEvaluationObjectTargetCycle_2 != null) {
                    receptionServiceReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1089104_1_47681
                }

                /*约定出参：目标周期ID[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getEvaObjTargetCycleId(), "D3-查询执行周期对应目标周期详情(公共)-约定出参：目标周期ID-被评对象目标周期ID不能为空", false);
                receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        QueryLastTargetCycleDetailComRespDto retData = new QueryLastTargetCycleDetailComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setEvaObjTargetCycleId(receptionServiceRes_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1089122_1
        }


        return retData;
    }

    /**
     * D3执行补偿目标内容父或中周期自定义周期(公共)[9379]
     * gen by moon at 4/15/2024, 1:33:59 AM
     */
    @Trace(operationName = "D3执行补偿目标内容父或中周期自定义周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCompensateTargetContFatherOrMidCycleCustExeCycleComRespDto implementCompensateTargetContFatherOrMidCycleCustExeCycleCom(ImplementCompensateTargetContFatherOrMidCycleCustExeCycleComReqDto reqDto) {


        //virtualUsage D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）  66729
        ObtainEvaObjTargetCycleComRespDto obtainEvaObjTargetCycleComRespDto = null;
        ObtainEvaObjTargetCycleComReqDto obtainEvaObjTargetCycleComReqDto = new ObtainEvaObjTargetCycleComReqDto();
        obtainEvaObjTargetCycleComReqDto.setIsArchive("FALSE");//sourceId:1724327_1_66729
        if (reqDto != null) {
            obtainEvaObjTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1724314_1_66729
            obtainEvaObjTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1724316_1_66729
            obtainEvaObjTargetCycleComReqDto.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1724318_1_66729
            obtainEvaObjTargetCycleComReqDto.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1724343_1_66729
            obtainEvaObjTargetCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1724325_1_66729
        }

        /*D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）[9380]   */
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaObjTypeCode(), "D3执行补偿目标内容父或中周期自定义周期(公共)-D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）-被评对象类型编码不能为空", false);
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getTargetCycleContentId(), "D3执行补偿目标内容父或中周期自定义周期(公共)-D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）-关联目标内容ID不能为空", false);
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaluationTemplateId(), "D3执行补偿目标内容父或中周期自定义周期(公共)-D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）-冗余评价模板ID不能为空", false);
        Assert.isNull(obtainEvaObjTargetCycleComReqDto.getIsArchive(), "D3执行补偿目标内容父或中周期自定义周期(公共)-D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）-是否存档不能为空", false);
        obtainEvaObjTargetCycleComRespDto = targetCycleService.obtainEvaObjTargetCycleCom(obtainEvaObjTargetCycleComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D2入参周期类型标识与目标父周期类型标识比较（判断是否相同）  66730
        ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
        if (obtainEvaObjTargetCycleComRespDto != null) {
            ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto = new ImplementStringEfficiencyCheckComReqDto();
            if (reqDto != null) {
                implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1724162_1_66730
            }
            if (obtainEvaObjTargetCycleComRespDto != null) {
                implementStringEfficiencyCheckComReqDto.setComparisonString(obtainEvaObjTargetCycleComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1724163_1_66730
            }

            /*D2入参周期类型标识与目标父周期类型标识比较（判断是否相同）[5774]   */
            Assert.isNull(implementStringEfficiencyCheckComReqDto.getReferenceString(), "D3执行补偿目标内容父或中周期自定义周期(公共)-D2入参周期类型标识与目标父周期类型标识比较（判断是否相同）-参照字符串不能为空", false);
            implementStringEfficiencyCheckComRespDto = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE"))) {
            //if(D2入参周期类型标识与目标父或中周期类型标识比较（判断是否相同）.字符串对比结果 等于 否)  66731

            ImplementAddTargetContExecuteCycleComRespDto implementAddTargetContExecuteCycleComRespDto = null;
            ImplementAddTargetContExecuteCycleComReqDto implementAddTargetContExecuteCycleComReqDto = new ImplementAddTargetContExecuteCycleComReqDto();
            if (reqDto != null) {
                implementAddTargetContExecuteCycleComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1724160_1_66732
                implementAddTargetContExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1724159_1_66732
            }

            /*D3新增目标内容父周期自定义执行周期(公共)[6527]   */
            Assert.isNull(implementAddTargetContExecuteCycleComReqDto.getEvaObjTargetCycleId(), "D3执行补偿目标内容父或中周期自定义周期(公共)-D3新增目标内容父周期自定义执行周期(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(implementAddTargetContExecuteCycleComReqDto.getEvaluationTemplateId(), "D3执行补偿目标内容父或中周期自定义周期(公共)-D3新增目标内容父周期自定义执行周期(公共)-冗余评价模板ID不能为空", false);
            implementAddTargetContExecuteCycleComRespDto = targetContentService.implementAddTargetContExecuteCycleCom(implementAddTargetContExecuteCycleComReqDto)/*vcase invoke isSameApp*/;


        }
        ImplementCompensateTargetContFatherOrMidCycleCustExeCycleComRespDto retData = new ImplementCompensateTargetContFatherOrMidCycleCustExeCycleComRespDto();


        return retData;
    }

    /**
     * D3新增目标内容过程执行周期阶段(公共)[9382]
     * gen by moon at 6/22/2024, 12:20:52 PM
     */
    @Trace(operationName = "D3新增目标内容过程执行周期阶段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddTargetConProgressExecuteCycleComRespDto addTargetConProgressExecuteCycleCom(AddTargetConProgressExecuteCycleComReqDto reqDto) {


        if ((reqDto != null && reqDto.getSubCycleList() != null && reqDto.getSubCycleList().size() > 0)) {
            //if(D3新增目标内容过程执行周期阶段(公共).子周期列表数据集条数 大于 0)  66740

//ModelCode: circulationCollections
            for (SubCycleDto circulationCollectionsRes : reqDto.getSubCycleList()) {

                AnalysisTargetContentCustomProcessExecutionCycleRangeComRespDto analysisTargetContentCustomProcessExecutionCycleRangeComRespDto = null;
                AnalysisTargetContentCustomProcessExecutionCycleRangeComReqDto analysisTargetContentCustomProcessExecutionCycleRangeComReqDto = new AnalysisTargetContentCustomProcessExecutionCycleRangeComReqDto();
                if (circulationCollectionsRes != null) {
                    analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1880507_1_70446
                    analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1880508_1_70446
                    analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setTargetActualStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1880509_1_70446
                    analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setTargetActualEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1880510_1_70446
                }
                if (reqDto != null) {
                    analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1880511_1_70446
                    analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1880513_1_70446
                    analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1880512_1_70446
                }

                /*D3分析目标内容自定义过程执行周期范围(公共)[9835]   */
                Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getEvaObjTargetCycleId(), "D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getCycleId(), "D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-周期ID不能为空", false);
                Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getTargetActualStartTime(), "D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-成果汇报开始时间不能为空", false);
                Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getTargetActualEndtTime(), "D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-成果汇报结束时间不能为空", false);
                Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getTargetCycleContentId(), "D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getTargetId(), "D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-冗余目标ID不能为空", false);
                Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getEvaluationTemplateId(), "D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-冗余评价模板ID不能为空", false);
                analysisTargetContentCustomProcessExecutionCycleRangeComRespDto = analysisTargetContentCustomProcessExecutionCycleRangeCom(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto)/*vcase invoke 同服务,同domain*/;


                LoopUpdateTargetConExecuteCycleStageComRespDto loopUpdateTargetConExecuteCycleStageComRespDto = null;
                if (analysisTargetContentCustomProcessExecutionCycleRangeComRespDto != null) {
                    LoopUpdateTargetConExecuteCycleStageComReqDto loopUpdateTargetConExecuteCycleStageComReqDto = new LoopUpdateTargetConExecuteCycleStageComReqDto();
                    if (analysisTargetContentCustomProcessExecutionCycleRangeComRespDto != null && analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList())) {
                        loopUpdateTargetConExecuteCycleStageComReqDto.setExecuteCycleStageList(//objList-to-objLists
                                analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList().stream().map(item -> {
                                    ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
                                    if (item != null) {
                                        elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:347662_2_66799
                                        elm.setRelateExecuteCycleStageId(item.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:345859_2_66799
                                        elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:345828_2_66799
                                        elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:345829_2_66799
                                        elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:345830_2_66799
                                        elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:345831_2_66799
                                        elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:345832_2_66799
                                        elm.setCycleTypeInstanceCode(item.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:345833_2_66799
                                        elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:345835_2_66799
                                        elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:345836_2_66799
                                        elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:345837_2_66799
                                        elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:345838_2_66799
                                        elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:345839_2_66799
                                        elm.setIsDefinedExecuteCycleStage(item.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:345840_2_66799
                                        elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:345842_2_66799
                                        elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:345843_2_66799
                                        elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:345844_2_66799
                                        elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:345845_2_66799
                                        elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:345846_2_66799
                                        elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:345847_2_66799
                                        elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:345848_2_66799
                                        elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:345849_2_66799
                                        elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:345851_2_66799
                                        elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:345850_2_66799
                                        elm.setRelateContentTypeCode(item.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:345852_2_66799
                                        elm.setRelateContentId(item.getRelateContentId());//SimpleFieldAssign//sourceId:345853_2_66799
                                        elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:345856_2_66799
                                        elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:345857_2_66799
                                    }
                                    if (reqDto != null) {
                                        elm.setTargetId(reqDto.getTargetId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:345854_2_66799
                                        elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:345855_2_66799
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1728290_1_66799
                    }

                    /*D3循环更新目标内容执行周期阶段(公共)[9388]   */

                    loopUpdateTargetConExecuteCycleStageComRespDto = loopUpdateTargetConExecuteCycleStageCom(loopUpdateTargetConExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;


                }
                ImplementModifyStartOrEndDefinedExecCycleComRespDto implementModifyStartOrEndDefinedExecCycleComRespDto = null;
                if (analysisTargetContentCustomProcessExecutionCycleRangeComRespDto != null) {
                    ImplementModifyStartOrEndDefinedExecCycleComReqDto implementModifyStartOrEndDefinedExecCycleComReqDto = new ImplementModifyStartOrEndDefinedExecCycleComReqDto();
                    implementModifyStartOrEndDefinedExecCycleComReqDto.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1887116_1_70600
                    implementModifyStartOrEndDefinedExecCycleComReqDto.setIsProcessCycleStage("TRUE");//sourceId:1887117_1_70600
                    if (analysisTargetContentCustomProcessExecutionCycleRangeComRespDto != null) {
                        implementModifyStartOrEndDefinedExecCycleComReqDto.setExecuteCycleStageList(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getSubCycleStartTimeExecuteCycleStageList());//list-field-assign//sourceId:1887114_1_70600
                    }
                    if (circulationCollectionsRes != null) {
                        implementModifyStartOrEndDefinedExecCycleComReqDto.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1887119_1_70600
                        implementModifyStartOrEndDefinedExecCycleComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887115_1_70600
                    }
                    if (reqDto != null) {
                        implementModifyStartOrEndDefinedExecCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887118_1_70600
                    }

                    /*D3执行修正子周期开始或结束的自定义过程执行周期(公共)[9847]   */
                    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto.getEvaObjTargetCycleId(), "D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-被评对象目标周期ID不能为空", false);
                    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto.getIsDefinedExecuteCycleStage(), "D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-是否自定义执行周期阶段不能为空", false);
                    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto.getIsProcessCycleStage(), "D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-是否过程周期阶段不能为空", false);
                    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto.getEvaluationTemplateId(), "D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-冗余评价模板ID不能为空", false);
                    implementModifyStartOrEndDefinedExecCycleComRespDto = implementModifyStartOrEndDefinedExecCycleCom(implementModifyStartOrEndDefinedExecCycleComReqDto)/*vcase invoke 同服务,同domain*/;


                }
                ImplementModifyStartOrEndDefinedExecCycleComRespDto implementModifyStartOrEndDefinedExecCycleComRespDto_1 = null;
                if (analysisTargetContentCustomProcessExecutionCycleRangeComRespDto != null) {
                    ImplementModifyStartOrEndDefinedExecCycleComReqDto implementModifyStartOrEndDefinedExecCycleComReqDto_1 = new ImplementModifyStartOrEndDefinedExecCycleComReqDto();
                    implementModifyStartOrEndDefinedExecCycleComReqDto_1.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1887116_1_70601
                    implementModifyStartOrEndDefinedExecCycleComReqDto_1.setIsProcessCycleStage("TRUE");//sourceId:1887117_1_70601
                    if (analysisTargetContentCustomProcessExecutionCycleRangeComRespDto != null) {
                        implementModifyStartOrEndDefinedExecCycleComReqDto_1.setExecuteCycleStageList(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getSubCycleEndTimeExecuteCycleStageList());//list-field-assign//sourceId:1887114_1_70601
                    }
                    if (circulationCollectionsRes != null) {
                        implementModifyStartOrEndDefinedExecCycleComReqDto_1.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1887120_1_70601
                        implementModifyStartOrEndDefinedExecCycleComReqDto_1.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887115_1_70601
                    }
                    if (reqDto != null) {
                        implementModifyStartOrEndDefinedExecCycleComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887118_1_70601
                    }

                    /*D3执行修正子周期开始或结束的自定义过程执行周期(公共)[9847]   */
                    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto_1.getEvaObjTargetCycleId(), "D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-被评对象目标周期ID不能为空", false);
                    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto_1.getIsDefinedExecuteCycleStage(), "D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-是否自定义执行周期阶段不能为空", false);
                    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto_1.getIsProcessCycleStage(), "D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-是否过程周期阶段不能为空", false);
                    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto_1.getEvaluationTemplateId(), "D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-冗余评价模板ID不能为空", false);
                    implementModifyStartOrEndDefinedExecCycleComRespDto_1 = implementModifyStartOrEndDefinedExecCycleCom(implementModifyStartOrEndDefinedExecCycleComReqDto_1)/*vcase invoke 同服务,同domain*/;


                }
                if ((analysisTargetContentCustomProcessExecutionCycleRangeComRespDto != null && analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList() != null && analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList().size() > 0)) {
                    //if(D3分析目标内容自定义过程执行周期范围(公共).执行周期阶段列表数据集条数 大于 0)  66808

                    boolean bOOLEAN;
                    OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = new OmsEvaluationObjectTargetCycle();
                    omsEvaluationObjectTargetCycle.setHaveProcessCycle("TRUE");//sourceId:1728787_1_66809
                    if (circulationCollectionsRes != null) {
                        omsEvaluationObjectTargetCycle.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1728786_1_66809
                    }

                    /*3-3-09修改被评对象目标周期[2317]   */
                    Assert.isNull(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId(), "D3新增目标内容过程执行周期阶段(公共)-3-3-09修改被评对象目标周期-被评对象目标周期ID不能为空", false);
                    Assert.isNull(omsEvaluationObjectTargetCycle.getHaveProcessCycle(), "D3新增目标内容过程执行周期阶段(公共)-3-3-09修改被评对象目标周期-是否有过程周期不能为空", false);
                    bOOLEAN = mOmsEvaluationObjectTargetCycleService.updateEvaObjTargetCycle(omsEvaluationObjectTargetCycle)/*vcase invoke 本地 method 方法调用;*/;


                }
//ModelCode: circulationEnd
            }

        }
        AddTargetConProgressExecuteCycleComRespDto retData = new AddTargetConProgressExecuteCycleComRespDto();


        return retData;
    }

    /**
     * D3新增目标内容工作周期执行周期阶段(公共)[9385]
     * gen by moon at 4/16/2024, 7:15:22 PM
     */
    @Trace(operationName = "D3新增目标内容工作周期执行周期阶段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddTargetConWorkExecuteCycleComRespDto addTargetConWorkExecuteCycleCom(AddTargetConWorkExecuteCycleComReqDto reqDto) {


        //virtualUsage D3-3查询被评对象目标周期列表(公共)  66765
        QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto = null;
        QueryEvaObjTargetCycleListComReqDto queryEvaObjTargetCycleListComReqDto = new QueryEvaObjTargetCycleListComReqDto();
        queryEvaObjTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1725874_1_66765
        if (reqDto != null) {
            queryEvaObjTargetCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1725869_1_66765
            queryEvaObjTargetCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1725870_1_66765
            queryEvaObjTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1725872_1_66765
            queryEvaObjTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1725875_1_66765
        }

        /*D3-3查询被评对象目标周期列表(公共)[3451]   */
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjEntityId(), "D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjTypeCode(), "D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentId(), "D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsArchive(), "D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-是否存档不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaluationTemplateId(), "D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-冗余评价模板ID不能为空", false);
        queryEvaObjTargetCycleListComRespDto = targetCycleService.queryEvaObjTargetCycleListCom(queryEvaObjTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


        if ((queryEvaObjTargetCycleListComRespDto != null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() != null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().size() > 0)) {
            //if(D3-3查询被评对象目标周期列表（父、子、中工作周期）.被评对象目标周期列表数据集条数 大于 0)  66766

//ModelCode: circulationCollections
            for (EvaObjTargetCycleDto circulationCollectionsRes : queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList()) {

                AddTargetContenteExecutionCycleComRespDto addTargetContenteExecutionCycleComRespDto = null;
                AddTargetContenteExecutionCycleComReqDto addTargetContenteExecutionCycleComReqDto = new AddTargetContenteExecutionCycleComReqDto();
                addTargetContenteExecutionCycleComReqDto.setIsProcessCycleStage("FALSE");//sourceId:1728300_1_66801
                addTargetContenteExecutionCycleComReqDto.setIsCurrentCycle("FALSE");//sourceId:1728307_1_66801
                addTargetContenteExecutionCycleComReqDto.setIsNextCycle("FALSE");//sourceId:1728308_1_66801
                addTargetContenteExecutionCycleComReqDto.setIsStartCycle("FALSE");//sourceId:1728309_1_66801
                addTargetContenteExecutionCycleComReqDto.setIsEndCycle("FALSE");//sourceId:1728310_1_66801
                addTargetContenteExecutionCycleComReqDto.setIsLastCycle("FALSE");//sourceId:1728315_1_66801
                if (circulationCollectionsRes != null) {
                    addTargetContenteExecutionCycleComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1728292_1_66801
                    addTargetContenteExecutionCycleComReqDto.setCycleStandardName(circulationCollectionsRes.getCycleStandardName());//SimpleFieldAssign//sourceId:1728322_1_66801
                    addTargetContenteExecutionCycleComReqDto.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1728293_1_66801
                    addTargetContenteExecutionCycleComReqDto.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1728294_1_66801
                    addTargetContenteExecutionCycleComReqDto.setCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:1728295_1_66801
                    addTargetContenteExecutionCycleComReqDto.setCycleTypeInstanceCode(circulationCollectionsRes.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1728296_1_66801
                    addTargetContenteExecutionCycleComReqDto.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1728302_1_66801
                    addTargetContenteExecutionCycleComReqDto.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1728303_1_66801
                    addTargetContenteExecutionCycleComReqDto.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1728304_1_66801
                    addTargetContenteExecutionCycleComReqDto.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1728305_1_66801
                    addTargetContenteExecutionCycleComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1728291_1_66801
                    addTargetContenteExecutionCycleComReqDto.setIsParentCycle(circulationCollectionsRes.getIsParentCycle());//SimpleFieldAssign//sourceId:1728297_1_66801
                    addTargetContenteExecutionCycleComReqDto.setIsMetaphase(circulationCollectionsRes.getIsMetaphase());//SimpleFieldAssign//sourceId:1728298_1_66801
                    addTargetContenteExecutionCycleComReqDto.setIsSubCycle(circulationCollectionsRes.getIsSubCycle());//SimpleFieldAssign//sourceId:1728299_1_66801
                    addTargetContenteExecutionCycleComReqDto.setEvaTempCreateTime(circulationCollectionsRes.getSortCreateTime());//SimpleFieldAssign//sourceId:1728318_1_66801
                    addTargetContenteExecutionCycleComReqDto.setOrderNumber(circulationCollectionsRes.getOrderNumber());//SimpleFieldAssign//sourceId:1728317_1_66801
                    addTargetContenteExecutionCycleComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1728311_1_66801
                    addTargetContenteExecutionCycleComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1728312_1_66801
                }
                if (reqDto != null) {
                    addTargetContenteExecutionCycleComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1728301_1_66801
                    addTargetContenteExecutionCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1728313_1_66801
                    addTargetContenteExecutionCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1728314_1_66801
                }

                /*D3新增目标内容执行周期(公共)[9386]   */
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getPeriodId(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期ID不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleStandardName(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期名称不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleStartTime(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期开始时间不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleEndTime(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期结束时间不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleTypeCode(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期类型标识不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getFillStartTime(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-填报开始时间不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getFillEndtTime(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-填报结束时间不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsProcessCycleStage(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否过程周期阶段不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsDefinedExecuteCycleStage(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否自定义执行周期阶段不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsCurrentCycle(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级/子周期当前不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsNextCycle(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级/子周期下一个不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsStartCycle(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否开始子周期不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsEndCycle(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否截止子周期不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsLastCycle(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级周期不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaObjTargetCycleId(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsParentCycle(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否父周期不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsMetaphase(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否中期不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsSubCycle(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否子周期不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaTempCreateTime(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-评价模板创建时间不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getOrderNumber(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期排序不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetCycleContentTypeCode(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetCycleContentId(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetId(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-冗余目标ID不能为空", false);
                Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaluationTemplateId(), "D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-冗余评价模板ID不能为空", false);
                addTargetContenteExecutionCycleComRespDto = addTargetContenteExecutionCycleCom(addTargetContenteExecutionCycleComReqDto)/*vcase invoke 同服务,同domain*/;


//ModelCode: circulationEnd
            }

        }
        AddTargetConWorkExecuteCycleComRespDto retData = new AddTargetConWorkExecuteCycleComRespDto();


        return retData;
    }

    /**
     * D3新增目标内容执行周期(公共)[9386]
     * gen by moon at 5/7/2024, 11:20:45 PM
     */
    @Trace(operationName = "D3新增目标内容执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddTargetContenteExecutionCycleComRespDto addTargetContenteExecutionCycleCom(AddTargetContenteExecutionCycleComReqDto reqDto) {


        String string_1 = null;
//virtualUsage 3-3-07查询执行周期阶段详情  66771
        OmsExecuteCycleStage omsExecuteCycleStage = null;
        QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
        queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1726051_1_66771
        if (reqDto != null) {
            queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1739250_1_66771
            queryExecuteCycleStageDetailReq.setCycleId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1726048_1_66771
            queryExecuteCycleStageDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1726049_1_66771
            queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1726050_1_66771
        }

        /*3-3-07查询执行周期阶段详情[2429]   */
        Assert.isNull(queryExecuteCycleStageDetailReq.getEvaObjTargetCycleId(), "D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(), "D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(), "D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-关联目标内容ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(), "D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
        omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsExecuteCycleStage == null)) {
            //if(3-3-07查询执行周期阶段详情.出参 值等于空 )  66775

            String string = null;
            OmsExecuteCycleStage omsExecuteCycleStage_2 = new OmsExecuteCycleStage();
            if (reqDto != null) {
                omsExecuteCycleStage_2.setLastExecuteCycleStageId(reqDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728228_1_66778
                omsExecuteCycleStage_2.setRelateExecuteCycleStageId(reqDto.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728229_1_66778
                omsExecuteCycleStage_2.setCycleId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1725990_1_66778
                omsExecuteCycleStage_2.setCycleStandardName(reqDto.getCycleStandardName());//SimpleFieldAssign//sourceId:1726011_1_66778
                omsExecuteCycleStage_2.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1726012_1_66778
                omsExecuteCycleStage_2.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1726013_1_66778
                omsExecuteCycleStage_2.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1726014_1_66778
                omsExecuteCycleStage_2.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1726020_1_66778
                omsExecuteCycleStage_2.setFillStartTime(reqDto.getFillStartTime());//SimpleFieldAssign//sourceId:1726006_1_66778
                omsExecuteCycleStage_2.setFillEndtTime(reqDto.getFillEndtTime());//SimpleFieldAssign//sourceId:1726007_1_66778
                omsExecuteCycleStage_2.setEvaluateStartTime(reqDto.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1726008_1_66778
                omsExecuteCycleStage_2.setEvaluateEndtTime(reqDto.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1726009_1_66778
                omsExecuteCycleStage_2.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1725996_1_66778
                omsExecuteCycleStage_2.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1725997_1_66778
                omsExecuteCycleStage_2.setIsSameSceneCurrentSubCycle(reqDto.getIsSameSceneCurrentSubCycle());//SimpleFieldAssign//sourceId:1728230_1_66778
                omsExecuteCycleStage_2.setIsCurrentCycle(reqDto.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1726016_1_66778
                omsExecuteCycleStage_2.setIsNextCycle(reqDto.getIsNextCycle());//SimpleFieldAssign//sourceId:1726017_1_66778
                omsExecuteCycleStage_2.setIsStartCycle(reqDto.getIsStartCycle());//SimpleFieldAssign//sourceId:1726001_1_66778
                omsExecuteCycleStage_2.setIsEndCycle(reqDto.getIsEndCycle());//SimpleFieldAssign//sourceId:1726002_1_66778
                omsExecuteCycleStage_2.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1726003_1_66778
                omsExecuteCycleStage_2.setNextCyclePeriod(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1726019_1_66778
                omsExecuteCycleStage_2.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1726018_1_66778
                omsExecuteCycleStage_2.setIsFatherCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1725993_1_66778
                omsExecuteCycleStage_2.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1725995_1_66778
                omsExecuteCycleStage_2.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1725994_1_66778
                omsExecuteCycleStage_2.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1725998_1_66778
                omsExecuteCycleStage_2.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1725999_1_66778
                omsExecuteCycleStage_2.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1726005_1_66778
                omsExecuteCycleStage_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1726000_1_66778
                omsExecuteCycleStage_2.setOrderNumber(reqDto.getOrderNumber());//SimpleFieldAssign//sourceId:1725992_1_66778
                omsExecuteCycleStage_2.setEvaTempCreateTime(reqDto.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1725991_1_66778
            }

            /*3-3-07新增执行周期阶段[2354]   */
            Assert.isNull(omsExecuteCycleStage_2.getCycleId(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getCycleStandardName(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getCycleStartTime(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getCycleEndTime(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getCycleTypeCode(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getFillStartTime(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getFillEndtTime(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getIsProcessCycleStage(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getIsDefinedExecuteCycleStage(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getIsStartCycle(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否开始子周期不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getIsEndCycle(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否截止子周期不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getIsLastCycle(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getEvaObjTargetCycleId(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getIsFatherCycle(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getIsMetaphase(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getIsSubCycle(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getRelateContentTypeCode(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getRelateContentId(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getTargetId(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getEvaluationTemplateId(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getOrderNumber(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期排序不能为空", false);
            Assert.isNull(omsExecuteCycleStage_2.getEvaTempCreateTime(), "D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空", false);
            string = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;


            string_1 = string;
        } else if ((omsExecuteCycleStage != null)) {
            //elseif(3-3-07查执行周期阶段是否存在.出参 值不等于空 )  66776

            boolean bOOLEAN;
            if (omsExecuteCycleStage != null) {
                OmsExecuteCycleStage omsExecuteCycleStage_3 = new OmsExecuteCycleStage();
                if (reqDto != null) {
                    omsExecuteCycleStage_3.setLastExecuteCycleStageId(reqDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728258_1_66777
                    omsExecuteCycleStage_3.setRelateExecuteCycleStageId(reqDto.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728259_1_66777
                    omsExecuteCycleStage_3.setCycleId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1728281_1_66777
                    omsExecuteCycleStage_3.setCycleStandardName(reqDto.getCycleStandardName());//SimpleFieldAssign//sourceId:1728282_1_66777
                    omsExecuteCycleStage_3.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1728261_1_66777
                    omsExecuteCycleStage_3.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1728260_1_66777
                    omsExecuteCycleStage_3.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1728283_1_66777
                    omsExecuteCycleStage_3.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1728284_1_66777
                    omsExecuteCycleStage_3.setFillStartTime(reqDto.getFillStartTime());//SimpleFieldAssign//sourceId:1727477_1_66777
                    omsExecuteCycleStage_3.setFillEndtTime(reqDto.getFillEndtTime());//SimpleFieldAssign//sourceId:1727478_1_66777
                    omsExecuteCycleStage_3.setEvaluateStartTime(reqDto.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1727479_1_66777
                    omsExecuteCycleStage_3.setEvaluateEndtTime(reqDto.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1727480_1_66777
                    omsExecuteCycleStage_3.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1728272_1_66777
                    omsExecuteCycleStage_3.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1728285_1_66777
                    omsExecuteCycleStage_3.setIsSameSceneCurrentSubCycle(reqDto.getIsSameSceneCurrentSubCycle());//SimpleFieldAssign//sourceId:1728286_1_66777
                    omsExecuteCycleStage_3.setIsCurrentCycle(reqDto.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1728263_1_66777
                    omsExecuteCycleStage_3.setIsNextCycle(reqDto.getIsNextCycle());//SimpleFieldAssign//sourceId:1728265_1_66777
                    omsExecuteCycleStage_3.setIsStartCycle(reqDto.getIsStartCycle());//SimpleFieldAssign//sourceId:1728264_1_66777
                    omsExecuteCycleStage_3.setIsEndCycle(reqDto.getIsEndCycle());//SimpleFieldAssign//sourceId:1728266_1_66777
                    omsExecuteCycleStage_3.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1728267_1_66777
                    omsExecuteCycleStage_3.setNextCyclePeriod(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1728271_1_66777
                    omsExecuteCycleStage_3.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1728257_1_66777
                    omsExecuteCycleStage_3.setIsFatherCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1728268_1_66777
                    omsExecuteCycleStage_3.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1728270_1_66777
                    omsExecuteCycleStage_3.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1728269_1_66777
                    omsExecuteCycleStage_3.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1728273_1_66777
                    omsExecuteCycleStage_3.setOrderNumber(reqDto.getOrderNumber());//SimpleFieldAssign//sourceId:1728287_1_66777
                }
                if (omsExecuteCycleStage != null) {
                    omsExecuteCycleStage_3.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1727476_1_66777
                }

                /*3-3-07修改执行周期阶段[2489]   */
                Assert.isNull(omsExecuteCycleStage_3.getExecuteCycleStageId(), "D3新增目标内容执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_3)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
        AddTargetContenteExecutionCycleComRespDto retData = new AddTargetContenteExecutionCycleComRespDto();
        if (string_1 != null) {
            retData.setExecuteCycleStageId(string_1);//SimpleFieldAssign//sourceId:1728288_1
        }


        return retData;
    }

    /**
     * D3新增目标内容执行周期阶段(公共)[9387]
     * gen by moon at 5/7/2024, 6:22:54 PM
     */
    @Trace(operationName = "D3新增目标内容执行周期阶段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddTargetConExecuteCycleStageComRespDto addTargetConExecuteCycleStageCom(AddTargetConExecuteCycleStageComReqDto reqDto) {


        //virtualUsage D3准备目标内容扩展信息(公共)  66783
        PreparationTargetContExtendInfoComRespDto preparationTargetContExtendInfoComRespDto = null;
        PreparationTargetContExtendInfoComReqDto preparationTargetContExtendInfoComReqDto = new PreparationTargetContExtendInfoComReqDto();
        if (reqDto != null) {
            preparationTargetContExtendInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1727381_1_66783
            preparationTargetContExtendInfoComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1727382_1_66783
            preparationTargetContExtendInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1727383_1_66783
        }

        /*D3准备目标内容扩展信息(公共)[8590]   */
        Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentId(), "D3新增目标内容执行周期阶段(公共)-D3准备目标内容扩展信息(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentTypeCode(), "D3新增目标内容执行周期阶段(公共)-D3准备目标内容扩展信息(公共)-关联目标内容类型编码不能为空", false);
        Assert.isNull(preparationTargetContExtendInfoComReqDto.getEvaluationTemplateId(), "D3新增目标内容执行周期阶段(公共)-D3准备目标内容扩展信息(公共)-冗余评价模板ID不能为空", false);
        preparationTargetContExtendInfoComRespDto = targetCalcService.preparationTargetContExtendInfoCom(preparationTargetContExtendInfoComReqDto)/*vcase invoke isSameApp*/;


        if ((preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE") && reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("EVA_PORTRAIT")) || (preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE") && reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("EVA_OBJECT")) || (preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE") && preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIsCustomObjective() != null && preparationTargetContExtendInfoComRespDto.getIsCustomObjective().equals("TRUE") && reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL")) || (preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() != null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE") && preparationTargetContExtendInfoComRespDto != null && preparationTargetContExtendInfoComRespDto.getIndicatorKind() != null && preparationTargetContExtendInfoComRespDto.getIndicatorKind().equals("KEY_RESULTS") && reqDto != null && reqDto.getEvaObjTypeCode() != null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
            //if((D3准备目标内容扩展信息(公共).是否开启自定义执行周期 等于 是 and D3新增目标内容执行周期阶段(公共).被评对象类型编码 等于 评价画像) or (D3准备目标内容扩展信息(公共).是否开启自定义执行周期 等于 是 and D3新增目标内容执行周期阶段(公共).被评对象类型编码 等于 评价对象) or (D3准备目标内容扩展信息(公共).是否开启自定义执行周期 等于 是 and D3准备目标内容扩展信息(公共).是否自定义OKR目标 等于 是 and D3新增目标内容执行周期阶段(公共).被评对象类型编码 等于 OKR责任主体个人) or (D3准备目标内容扩展信息(公共).是否开启自定义执行周期 等于 是 and D3准备目标内容扩展信息(公共).OKR目标属性 等于 关键成果KR and D3新增目标内容执行周期阶段(公共).被评对象类型编码 等于 OKR责任主体个人))  66784

            AddTargetConWorkExecuteCycleComRespDto addTargetConWorkExecuteCycleComRespDto = null;
            AddTargetConWorkExecuteCycleComReqDto addTargetConWorkExecuteCycleComReqDto = new AddTargetConWorkExecuteCycleComReqDto();
            addTargetConWorkExecuteCycleComReqDto.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1728791_1_66785
            if (reqDto != null) {
                addTargetConWorkExecuteCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1733246_1_66785
                addTargetConWorkExecuteCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1733245_1_66785
                addTargetConWorkExecuteCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1727046_1_66785
                addTargetConWorkExecuteCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1728792_1_66785
                addTargetConWorkExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1727048_1_66785
                addTargetConWorkExecuteCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1727049_1_66785
            }

            /*D3新增目标内容工作周期执行周期阶段(公共)[9385]   */
            Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getEvaObjEntityId(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-被评对象内容表主键ID不能为空", false);
            Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getEvaObjTypeCode(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-被评对象类型编码不能为空", false);
            Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getTargetCycleContentId(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getIsDefinedExecuteCycleStage(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-是否自定义执行周期阶段不能为空", false);
            Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getTargetId(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-冗余目标ID不能为空", false);
            Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getEvaluationTemplateId(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getSpaceId(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-创建于空间ID不能为空", false);
            addTargetConWorkExecuteCycleComRespDto = addTargetConWorkExecuteCycleCom(addTargetConWorkExecuteCycleComReqDto)/*vcase invoke 同服务,同domain*/;


            ImplementTargetConSubExecuteCycleStageComRespDto implementTargetConSubExecuteCycleStageComRespDto = null;
            ImplementTargetConSubExecuteCycleStageComReqDto implementTargetConSubExecuteCycleStageComReqDto = new ImplementTargetConSubExecuteCycleStageComReqDto();
            if (reqDto != null) {
                implementTargetConSubExecuteCycleStageComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1733255_1_66888
                implementTargetConSubExecuteCycleStageComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1733256_1_66888
                implementTargetConSubExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1731358_1_66888
                implementTargetConSubExecuteCycleStageComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1731361_1_66888
                implementTargetConSubExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1731359_1_66888
                implementTargetConSubExecuteCycleStageComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1731360_1_66888
            }

            /*D3执行回写目标内容子周期执行周期阶段(公共)[9392]   */
            Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getEvaObjEntityId(), "D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-被评对象内容表主键ID不能为空", false);
            Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getEvaObjTypeCode(), "D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-被评对象类型编码不能为空", false);
            Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getTargetCycleContentId(), "D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getTargetId(), "D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-冗余目标ID不能为空", false);
            Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getEvaluationTemplateId(), "D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getSpaceId(), "D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-创建于空间ID不能为空", false);
            implementTargetConSubExecuteCycleStageComRespDto = implementTargetConSubExecuteCycleStageCom(implementTargetConSubExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;


            RefreshTargetConParentAndMidExecuteCycleStageComRespDto refreshTargetConParentAndMidExecuteCycleStageComRespDto = null;
            RefreshTargetConParentAndMidExecuteCycleStageComReqDto refreshTargetConParentAndMidExecuteCycleStageComReqDto = new RefreshTargetConParentAndMidExecuteCycleStageComReqDto();
            refreshTargetConParentAndMidExecuteCycleStageComReqDto.setIsMetaphase("TRUE");//sourceId:1731349_1_66889
            refreshTargetConParentAndMidExecuteCycleStageComReqDto.setIsSubCycle("FALSE");//sourceId:1732593_1_66889
            if (reqDto != null) {
                refreshTargetConParentAndMidExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1731345_1_66889
                refreshTargetConParentAndMidExecuteCycleStageComReqDto.setSubcycleType(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1736176_1_66889
                refreshTargetConParentAndMidExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1731346_1_66889
            }

            /*D3更新目标内容中周期执行周期阶段(公共)[9393]   */
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getTargetCycleContentId(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getIsMetaphase(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-是否中期不能为空", false);
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getIsSubCycle(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-是否子周期不能为空", false);
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getSubcycleType(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-子周期周期类型不能为空", false);
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getEvaluationTemplateId(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-冗余评价模板ID不能为空", false);
            refreshTargetConParentAndMidExecuteCycleStageComRespDto = refreshTargetConParentAndMidExecuteCycleStageCom(refreshTargetConParentAndMidExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;


            RefreshTargetConParentAndMidExecuteCycleStageComRespDto refreshTargetConParentAndMidExecuteCycleStageComRespDto_2 = null;
            RefreshTargetConParentAndMidExecuteCycleStageComReqDto refreshTargetConParentAndMidExecuteCycleStageComReqDto_1 = new RefreshTargetConParentAndMidExecuteCycleStageComReqDto();
            refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setIsParentCycle("TRUE");//sourceId:1731356_1_66890
            refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setIsSubCycle("FALSE");//sourceId:1732592_1_66890
            if (reqDto != null) {
                refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1731353_1_66890
                refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setSubcycleType(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1736175_1_66890
                refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1731354_1_66890
            }

            /*D3更新目标内容父周期执行周期阶段(公共)[9393]   */
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getTargetCycleContentId(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getIsParentCycle(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-是否父周期不能为空", false);
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getIsSubCycle(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-是否子周期不能为空", false);
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getSubcycleType(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-子周期周期类型不能为空", false);
            Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getEvaluationTemplateId(), "D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-冗余评价模板ID不能为空", false);
            refreshTargetConParentAndMidExecuteCycleStageComRespDto_2 = refreshTargetConParentAndMidExecuteCycleStageCom(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1)/*vcase invoke 同服务,同domain*/;


            AddTargetConProgressExecuteCycleComRespDto addTargetConProgressExecuteCycleComRespDto = null;
            if (implementTargetConSubExecuteCycleStageComRespDto != null) {
                AddTargetConProgressExecuteCycleComReqDto addTargetConProgressExecuteCycleComReqDto = new AddTargetConProgressExecuteCycleComReqDto();
                if (implementTargetConSubExecuteCycleStageComRespDto != null && implementTargetConSubExecuteCycleStageComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(implementTargetConSubExecuteCycleStageComRespDto.getEvaObjTargetCycleList())) {
                    addTargetConProgressExecuteCycleComReqDto.setSubCycleList(implementTargetConSubExecuteCycleStageComRespDto.getEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, SubCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1727041_1_66786
                }
                if (reqDto != null) {
                    addTargetConProgressExecuteCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1784090_1_66786
                    addTargetConProgressExecuteCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1727045_1_66786
                    addTargetConProgressExecuteCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1727042_1_66786
                    addTargetConProgressExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1727043_1_66786
                }

                /*D3新增目标内容过程执行周期阶段(公共)[9382]   */
                Assert.isNull(addTargetConProgressExecuteCycleComReqDto.getTargetCycleContentTypeCode(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容过程执行周期阶段(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(addTargetConProgressExecuteCycleComReqDto.getTargetCycleContentId(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容过程执行周期阶段(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(addTargetConProgressExecuteCycleComReqDto.getTargetId(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容过程执行周期阶段(公共)-冗余目标ID不能为空", false);
                Assert.isNull(addTargetConProgressExecuteCycleComReqDto.getEvaluationTemplateId(), "D3新增目标内容执行周期阶段(公共)-D3新增目标内容过程执行周期阶段(公共)-冗余评价模板ID不能为空", false);
                addTargetConProgressExecuteCycleComRespDto = addTargetConProgressExecuteCycleCom(addTargetConProgressExecuteCycleComReqDto)/*vcase invoke 同服务,同domain*/;


            }
        }
        AddTargetConExecuteCycleStageComRespDto retData = new AddTargetConExecuteCycleStageComRespDto();


        return retData;
    }

    /**
     * D3循环更新目标内容执行周期阶段(公共)[9388]
     * gen by moon at 7/10/2024, 6:45:04 PM
     */
    @Trace(operationName = "D3循环更新目标内容执行周期阶段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public LoopUpdateTargetConExecuteCycleStageComRespDto loopUpdateTargetConExecuteCycleStageCom(LoopUpdateTargetConExecuteCycleStageComReqDto reqDto) {


        if ((reqDto != null && reqDto.getExecuteCycleStageList() != null && reqDto.getExecuteCycleStageList().size() > 0)) {
            //if(D3循环更新目标内容执行周期阶段(公共).执行周期阶段列表数据集条数 大于 0)  66789

//ModelCode: circulationCollections
            for (ExecuteCycleStageDto circulationCollectionsRes : reqDto.getExecuteCycleStageList()) {

                ObtainPreProgressExecuteCycleStageIdComRespDto obtainPreProgressExecuteCycleStageIdComRespDto = null;
                ObtainPreProgressExecuteCycleStageIdComReqDto obtainPreProgressExecuteCycleStageIdComReqDto = new ObtainPreProgressExecuteCycleStageIdComReqDto();
                if (circulationCollectionsRes != null) {
                    obtainPreProgressExecuteCycleStageIdComReqDto.setExecuteCycleStageId(circulationCollectionsRes.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1733057_1_66846
                    obtainPreProgressExecuteCycleStageIdComReqDto.setTargetCycleContentId(circulationCollectionsRes.getRelateContentId());//SimpleFieldAssign//sourceId:1737457_1_66846
                    obtainPreProgressExecuteCycleStageIdComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1733059_1_66846
                }

                /*D3获取上一个过程或子周期执行周期阶段ID(公共)[9389]   */
                Assert.isNull(obtainPreProgressExecuteCycleStageIdComReqDto.getTargetCycleContentId(), "D3循环更新目标内容执行周期阶段(公共)-D3获取上一个过程或子周期执行周期阶段ID(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(obtainPreProgressExecuteCycleStageIdComReqDto.getEvaluationTemplateId(), "D3循环更新目标内容执行周期阶段(公共)-D3获取上一个过程或子周期执行周期阶段ID(公共)-冗余评价模板ID不能为空", false);
                obtainPreProgressExecuteCycleStageIdComRespDto = obtainPreProgressExecuteCycleStageIdCom(obtainPreProgressExecuteCycleStageIdComReqDto)/*vcase invoke 同服务,同domain*/;


                OmsExecuteCycleStage omsExecuteCycleStage = null;
                QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
                queryExecuteCycleStageDetailReq.setIsProcessCycleStage("FALSE");//sourceId:1925271_1_71405
                queryExecuteCycleStageDetailReq.setIsSubCycle("TRUE");//sourceId:1925272_1_71405
                queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1925274_1_71405
                if (circulationCollectionsRes != null) {
                    queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1925270_1_71405
                    queryExecuteCycleStageDetailReq.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1925273_1_71405
                }

                /*3-3-07查询执行周期阶段详情[2429]   */
                Assert.isNull(queryExecuteCycleStageDetailReq.getEvaObjTargetCycleId(), "D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(), "D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getIsSubCycle(), "D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否子周期不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(), "D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                AddTargetContenteExecutionCycleComRespDto addTargetContenteExecutionCycleComRespDto = null;
                if (obtainPreProgressExecuteCycleStageIdComRespDto != null && omsExecuteCycleStage != null) {
                    AddTargetContenteExecutionCycleComReqDto addTargetContenteExecutionCycleComReqDto = new AddTargetContenteExecutionCycleComReqDto();
                    if (obtainPreProgressExecuteCycleStageIdComRespDto != null) {
                        addTargetContenteExecutionCycleComReqDto.setLastExecuteCycleStageId(obtainPreProgressExecuteCycleStageIdComRespDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728248_1_66791
                    }
                    if (omsExecuteCycleStage != null) {
                        addTargetContenteExecutionCycleComReqDto.setRelateExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728249_1_66791
                    }
                    if (circulationCollectionsRes != null) {
                        addTargetContenteExecutionCycleComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1727758_1_66791
                        addTargetContenteExecutionCycleComReqDto.setCycleStandardName(circulationCollectionsRes.getCycleStandardName());//SimpleFieldAssign//sourceId:1728256_1_66791
                        addTargetContenteExecutionCycleComReqDto.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1727759_1_66791
                        addTargetContenteExecutionCycleComReqDto.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1727760_1_66791
                        addTargetContenteExecutionCycleComReqDto.setCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:1727761_1_66791
                        addTargetContenteExecutionCycleComReqDto.setCycleTypeInstanceCode(circulationCollectionsRes.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1727762_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsProcessCycleStage(circulationCollectionsRes.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1727766_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsDefinedExecuteCycleStage(circulationCollectionsRes.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1727767_1_66791
                        addTargetContenteExecutionCycleComReqDto.setFillStartTime(circulationCollectionsRes.getFillStartTime());//SimpleFieldAssign//sourceId:1727768_1_66791
                        addTargetContenteExecutionCycleComReqDto.setFillEndtTime(circulationCollectionsRes.getFillEndtTime());//SimpleFieldAssign//sourceId:1727769_1_66791
                        addTargetContenteExecutionCycleComReqDto.setEvaluateStartTime(circulationCollectionsRes.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1727770_1_66791
                        addTargetContenteExecutionCycleComReqDto.setEvaluateEndtTime(circulationCollectionsRes.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1727771_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsCurrentCycle(circulationCollectionsRes.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1727773_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsNextCycle(circulationCollectionsRes.getIsNextCycle());//SimpleFieldAssign//sourceId:1727774_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsStartCycle(circulationCollectionsRes.getIsStartCycle());//SimpleFieldAssign//sourceId:1727775_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsEndCycle(circulationCollectionsRes.getIsEndCycle());//SimpleFieldAssign//sourceId:1727776_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:1728206_1_66791
                        addTargetContenteExecutionCycleComReqDto.setNextCyclePeriod(circulationCollectionsRes.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1728207_1_66791
                        addTargetContenteExecutionCycleComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1727757_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsParentCycle(circulationCollectionsRes.getIsFatherCycle());//SimpleFieldAssign//sourceId:1727763_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsMetaphase(circulationCollectionsRes.getIsMetaphase());//SimpleFieldAssign//sourceId:1727764_1_66791
                        addTargetContenteExecutionCycleComReqDto.setIsSubCycle(circulationCollectionsRes.getIsSubCycle());//SimpleFieldAssign//sourceId:1727765_1_66791
                        addTargetContenteExecutionCycleComReqDto.setOrderNumber(circulationCollectionsRes.getOrderNumber());//SimpleFieldAssign//sourceId:1728208_1_66791
                        addTargetContenteExecutionCycleComReqDto.setEvaTempCreateTime(circulationCollectionsRes.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1728209_1_66791
                        addTargetContenteExecutionCycleComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1727777_1_66791
                        addTargetContenteExecutionCycleComReqDto.setTargetCycleContentId(circulationCollectionsRes.getRelateContentId());//SimpleFieldAssign//sourceId:1727778_1_66791
                        addTargetContenteExecutionCycleComReqDto.setTargetId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:1727779_1_66791
                        addTargetContenteExecutionCycleComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1727780_1_66791
                    }

                    /*D3新增目标内容执行周期(公共)[9386]   */
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getPeriodId(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期ID不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleStandardName(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期名称不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleStartTime(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期开始时间不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleEndTime(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期结束时间不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleTypeCode(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期类型标识不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsProcessCycleStage(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否过程周期阶段不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsDefinedExecuteCycleStage(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否自定义执行周期阶段不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getFillStartTime(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-填报开始时间不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getFillEndtTime(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-填报结束时间不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsCurrentCycle(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级/子周期当前不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsNextCycle(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级/子周期下一个不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsStartCycle(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否开始子周期不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsEndCycle(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否截止子周期不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsLastCycle(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级周期不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaObjTargetCycleId(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-被评对象目标周期ID不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsParentCycle(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否父周期不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsMetaphase(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否中期不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsSubCycle(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否子周期不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getOrderNumber(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期排序不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaTempCreateTime(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-评价模板创建时间不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetCycleContentTypeCode(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-关联目标内容类型编码不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetCycleContentId(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetId(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-冗余目标ID不能为空", false);
                    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaluationTemplateId(), "D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-冗余评价模板ID不能为空", false);
                    addTargetContenteExecutionCycleComRespDto = addTargetContenteExecutionCycleCom(addTargetContenteExecutionCycleComReqDto)/*vcase invoke 同服务,同domain*/;


                }
//ModelCode: circulationEnd
            }

        }
        LoopUpdateTargetConExecuteCycleStageComRespDto retData = new LoopUpdateTargetConExecuteCycleStageComRespDto();


        return retData;
    }

    /**
     * D3获取上一个过程或子周期执行周期阶段ID(公共)[9389]
     * gen by moon at 4/19/2024, 1:00:49 AM
     */
    @Trace(operationName = "D3获取上一个过程或子周期执行周期阶段ID(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainPreProgressExecuteCycleStageIdComRespDto obtainPreProgressExecuteCycleStageIdCom(ObtainPreProgressExecuteCycleStageIdComReqDto reqDto) {


        ImplementSevenReceivingFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getExecuteCycleStageId() != null)) {
            //if(D3获取上一个过程或子周期执行周期阶段ID(公共).执行周期阶段ID 值不等于空 )  66836

            OmsExecuteCycleStage omsExecuteCycleStage = null;
            QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
            queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1733121_1_66838
            if (reqDto != null) {
                queryExecuteCycleStageDetailReq.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728976_1_66838
                queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1732754_1_66838
            }

            /*3-3-07查询发牌目标的上一个执行周期阶段的周期ID[2429]   */
            Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(), "D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询发牌目标的上一个执行周期阶段的周期ID-执行周期阶段ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询发牌目标的上一个执行周期阶段的周期ID-评价模板ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(), "D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询发牌目标的上一个执行周期阶段的周期ID-是否存档不能为空", false);
            omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
            if (omsExecuteCycleStage != null) {
                QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1 = new QueryExecuteCycleStageDetailReq();
                queryExecuteCycleStageDetailReq_1.setIsArchive("FALSE");//sourceId:1733125_1_66913
                if (reqDto != null) {
                    queryExecuteCycleStageDetailReq_1.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1737456_1_66913
                    queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1733124_1_66913
                }
                if (omsExecuteCycleStage != null) {
                    queryExecuteCycleStageDetailReq_1.setCycleId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:1733123_1_66913
                }

                /*3-3-07查询当前内容上一个刚增的执行周期阶段ID[2429]   */
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getRelateContentId(), "D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询当前内容上一个刚增的执行周期阶段ID-关联目标内容ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getCycleId(), "D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询当前内容上一个刚增的执行周期阶段ID-周期ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(), "D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询当前内容上一个刚增的执行周期阶段ID-评价模板ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsArchive(), "D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询当前内容上一个刚增的执行周期阶段ID-是否存档不能为空", false);
                omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: receptionService
            ImplementSevenReceivingFieldRespDto receptionServiceRes = null;
            if (omsExecuteCycleStage_2 != null) {
                ImplementSevenReceivingFieldReqDto receptionServiceReq = new ImplementSevenReceivingFieldReqDto();
                if (omsExecuteCycleStage_2 != null) {
                    receptionServiceReq.setExecuteCycleStageId(omsExecuteCycleStage_2.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1729314_1_66845
                }

                /*M3接收执行周期阶段ID[8654]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getExecuteCycleStageId(), "D3获取上一个过程或子周期执行周期阶段ID(公共)-M3接收执行周期阶段ID-执行周期阶段ID不能为空", false);
                receptionServiceRes = nbCustomExecutionCycle.implementSevenReceivingField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        }
        ObtainPreProgressExecuteCycleStageIdComRespDto retData = new ObtainPreProgressExecuteCycleStageIdComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setExecuteCycleStageId(receptionServiceRes_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1729322_1
        }


        return retData;
    }

    /**
     * D3执行回写目标内容子周期执行周期阶段(公共)[9392]
     * gen by moon at 7/7/2024, 12:05:04 PM
     */
    @Trace(operationName = "D3执行回写目标内容子周期执行周期阶段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTargetConSubExecuteCycleStageComRespDto implementTargetConSubExecuteCycleStageCom(ImplementTargetConSubExecuteCycleStageComReqDto reqDto) {


        QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto_1 = null;
//virtualUsage M3约定错误描述  69045
        //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
        ImplementFiveReceivingFieldReqDto receptionServiceReq = new ImplementFiveReceivingFieldReqDto();
        receptionServiceReq.setCustomField1("implementTargetConSubExecuteCycleStageCom");//CUSTOM_CONVENTION//sourceId:1817320_1_69045
        receptionServiceReq.setCustomField2("DATA_OBJECT");//CUSTOM_CONVENTION//sourceId:1817321_1_69045
        receptionServiceReq.setCustomField3("SINGLE_OBJECT");//CUSTOM_CONVENTION//sourceId:1817322_1_69045
        receptionServiceReq.setCustomField4("对不起，找不到当前目标内容目标子周期数据集~");//CUSTOM_CONVENTION//sourceId:1817323_1_69045
        receptionServiceReq.setCustomField5("对不起，找不到目标的目标子周期ID~");//CUSTOM_CONVENTION//sourceId:1817324_1_69045
        receptionServiceReq.setCustomField6("对不起，找不到目标的子周期执行周期阶段~");//CUSTOM_CONVENTION//sourceId:1817325_1_69045

        /*M3约定错误描述[8467]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段2不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField3(), "D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段3不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField4(), "D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段4不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField5(), "D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段5不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField6(), "D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段6不能为空", false);
        receptionServiceRes = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq);


//virtualUsage D3-3查询被评对象目标周期列表(公共)  66862
        QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto = null;
        QueryEvaObjTargetCycleListComReqDto queryEvaObjTargetCycleListComReqDto = new QueryEvaObjTargetCycleListComReqDto();
        queryEvaObjTargetCycleListComReqDto.setIsSubCycle("TRUE");//sourceId:1729839_1_66862
        queryEvaObjTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1732386_1_66862
        if (reqDto != null) {
            queryEvaObjTargetCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1729831_1_66862
            queryEvaObjTargetCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1729833_1_66862
            queryEvaObjTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1729836_1_66862
            queryEvaObjTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1729847_1_66862
        }

        /*D3-3查询被评对象目标周期列表(公共)[3451]   */
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjEntityId(), "D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjTypeCode(), "D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentId(), "D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsSubCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-是否子周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaluationTemplateId(), "D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsArchive(), "D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-是否存档不能为空", false);
        queryEvaObjTargetCycleListComRespDto = targetCycleService.queryEvaObjTargetCycleListCom(queryEvaObjTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


        queryEvaObjTargetCycleListComRespDto_1 = queryEvaObjTargetCycleListComRespDto;
        if ((queryEvaObjTargetCycleListComRespDto != null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() != null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().size() > 0)) {
            //if(D3-3查询被评对象目标周期列表-子周期.被评对象目标周期列表数据集条数 大于 0)  66863

//ModelCode: circulationCollections
            for (EvaObjTargetCycleDto circulationCollectionsRes : queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList()) {

                OmsExecuteCycleStage omsExecuteCycleStage = null;
                QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
                queryExecuteCycleStageDetailReq.setIsProcessCycleStage("FALSE");//sourceId:1732748_1_66875
                queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1732388_1_66875
                if (circulationCollectionsRes != null) {
                    queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1730719_1_66875
                    queryExecuteCycleStageDetailReq.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1730720_1_66875
                }
                if (reqDto != null) {
                    queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1730721_1_66875
                }

                /*3-3-07查询执行周期阶段详情[2429]   */
                Assert.isNull(queryExecuteCycleStageDetailReq.getEvaObjTargetCycleId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
                omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((omsExecuteCycleStage == null)) {
                    //if(3-3-07查询当前子周期执行周期阶段ID（出参主键用于修改）.出参 值等于空 )  69034

                    ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto = null;
                    ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto = new ImplementDebugBusinessDataRedisComReqDto();
                    implementDebugBusinessDataRedisComReqDto.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1816920_1_69048
                    if (receptionServiceRes != null) {
                        implementDebugBusinessDataRedisComReqDto.setDebugScene(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1816933_1_69048
                        implementDebugBusinessDataRedisComReqDto.setWrongObjectDescribe(receptionServiceRes.getCustomField6());//SimpleFieldAssign//sourceId:1816934_1_69048
                        implementDebugBusinessDataRedisComReqDto.setCustomField2(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1817347_1_69048
                    }
                    if (reqDto != null) {
                        implementDebugBusinessDataRedisComReqDto.setCustomField3(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817348_1_69048
                        implementDebugBusinessDataRedisComReqDto.setCustomField4(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817349_1_69048
                        implementDebugBusinessDataRedisComReqDto.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817350_1_69048
                        implementDebugBusinessDataRedisComReqDto.setCustomField7(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817352_1_69048
                        implementDebugBusinessDataRedisComReqDto.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817351_1_69048
                    }
                    if (circulationCollectionsRes != null) {
                        implementDebugBusinessDataRedisComReqDto.setCustomField8(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1817353_1_69048
                    }

                    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getBusinessDataObject(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空", false);
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getDebugScene(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空", false);
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getWrongObjectDescribe(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空", false);
                    implementDebugBusinessDataRedisComRespDto = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
                QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();

                queryEvaObjTargetCycleDetailReq.setIsSubCycle("TRUE");//sourceId:1732750_1_66879
                queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1754809_1_66879
                if (reqDto != null) {
                    queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1754808_1_66879
                    queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1732749_1_66879
                    queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1730969_1_66879
                    queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1730971_1_66879
                }
                if (circulationCollectionsRes != null) {
                    queryEvaObjTargetCycleDetailReq.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1730970_1_66879
                }

                /*3-3-09查被评对象目标周期详情[2313]   */
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsSubCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-是否子周期不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
                omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((omsEvaluationObjectTargetCycle != null && omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId() == null)) {
                    //if(3-3-09查目标的被评对象目标周期ID.被评对象目标周期ID 值等于空 )  69035

                    ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto_1 = null;
                    ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto_1 = new ImplementDebugBusinessDataRedisComReqDto();
                    implementDebugBusinessDataRedisComReqDto_1.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1816920_1_69047
                    if (receptionServiceRes != null) {
                        implementDebugBusinessDataRedisComReqDto_1.setDebugScene(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1816933_1_69047
                        implementDebugBusinessDataRedisComReqDto_1.setWrongObjectDescribe(receptionServiceRes.getCustomField6());//SimpleFieldAssign//sourceId:1816934_1_69047
                        implementDebugBusinessDataRedisComReqDto_1.setCustomField2(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1817347_1_69047
                    }
                    if (reqDto != null) {
                        implementDebugBusinessDataRedisComReqDto_1.setCustomField3(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817348_1_69047
                        implementDebugBusinessDataRedisComReqDto_1.setCustomField4(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817349_1_69047
                        implementDebugBusinessDataRedisComReqDto_1.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817350_1_69047
                        implementDebugBusinessDataRedisComReqDto_1.setCustomField7(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817352_1_69047
                        implementDebugBusinessDataRedisComReqDto_1.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817351_1_69047
                    }
                    if (circulationCollectionsRes != null) {
                        implementDebugBusinessDataRedisComReqDto_1.setCustomField8(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1817353_1_69047
                    }

                    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto_1.getBusinessDataObject(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空", false);
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto_1.getDebugScene(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空", false);
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto_1.getWrongObjectDescribe(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空", false);
                    implementDebugBusinessDataRedisComRespDto_1 = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
                if (omsEvaluationObjectTargetCycle != null) {
                    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1 = new QueryExecuteCycleStageDetailReq();
                    queryExecuteCycleStageDetailReq_1.setIsSubCycle("TRUE");//sourceId:1732752_1_66868
                    queryExecuteCycleStageDetailReq_1.setIsProcessCycleStage("FALSE");//sourceId:1732751_1_66868
                    queryExecuteCycleStageDetailReq_1.setIsArchive("FALSE");//sourceId:1732753_1_66868
                    if (omsEvaluationObjectTargetCycle != null) {
                        queryExecuteCycleStageDetailReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1731252_1_66868
                    }
                    if (circulationCollectionsRes != null) {
                        queryExecuteCycleStageDetailReq_1.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1731253_1_66868
                    }
                    if (reqDto != null) {
                        queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1731254_1_66868
                    }

                    /*3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等[2429]   */
                    Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaObjTargetCycleId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-被评对象目标周期ID不能为空", false);
                    Assert.isNull(queryExecuteCycleStageDetailReq_1.getCycleId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-周期ID不能为空", false);
                    Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsSubCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-是否子周期不能为空", false);
                    Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsProcessCycleStage(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-是否过程周期阶段不能为空", false);
                    Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-评价模板ID不能为空", false);
                    Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsArchive(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-是否存档不能为空", false);
                    omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                }
                if ((omsExecuteCycleStage_2 == null)) {
                    //if(3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等.出参 值等于空 )  69036

                    ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto_2 = null;
                    ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto_2 = new ImplementDebugBusinessDataRedisComReqDto();
                    implementDebugBusinessDataRedisComReqDto_2.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1816920_1_69046
                    if (receptionServiceRes != null) {
                        implementDebugBusinessDataRedisComReqDto_2.setDebugScene(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1816933_1_69046
                        implementDebugBusinessDataRedisComReqDto_2.setWrongObjectDescribe(receptionServiceRes.getCustomField5());//SimpleFieldAssign//sourceId:1816934_1_69046
                        implementDebugBusinessDataRedisComReqDto_2.setCustomField2(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1817347_1_69046
                    }
                    if (reqDto != null) {
                        implementDebugBusinessDataRedisComReqDto_2.setCustomField3(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817348_1_69046
                        implementDebugBusinessDataRedisComReqDto_2.setCustomField4(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817349_1_69046
                        implementDebugBusinessDataRedisComReqDto_2.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817350_1_69046
                        implementDebugBusinessDataRedisComReqDto_2.setCustomField7(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817352_1_69046
                        implementDebugBusinessDataRedisComReqDto_2.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817351_1_69046
                    }
                    if (circulationCollectionsRes != null) {
                        implementDebugBusinessDataRedisComReqDto_2.setCustomField8(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1817353_1_69046
                    }

                    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto_2.getBusinessDataObject(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空", false);
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto_2.getDebugScene(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空", false);
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto_2.getWrongObjectDescribe(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空", false);
                    implementDebugBusinessDataRedisComRespDto_2 = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                ObtainPreProgressExecuteCycleStageIdComRespDto obtainPreProgressExecuteCycleStageIdComRespDto = null;
                if (omsExecuteCycleStage_2 != null && omsExecuteCycleStage != null) {
                    ObtainPreProgressExecuteCycleStageIdComReqDto obtainPreProgressExecuteCycleStageIdComReqDto = new ObtainPreProgressExecuteCycleStageIdComReqDto();
                    if (omsExecuteCycleStage_2 != null) {
                        obtainPreProgressExecuteCycleStageIdComReqDto.setExecuteCycleStageId(omsExecuteCycleStage_2.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1733061_1_66865
                    }
                    if (omsExecuteCycleStage != null) {
                        obtainPreProgressExecuteCycleStageIdComReqDto.setTargetCycleContentId(omsExecuteCycleStage.getRelateContentId());//SimpleFieldAssign//sourceId:1737458_1_66865
                    }
                    if (reqDto != null) {
                        obtainPreProgressExecuteCycleStageIdComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1733063_1_66865
                    }

                    /*D3获取上一个过程或子周期执行周期阶段ID(公共)[9389]   */
                    Assert.isNull(obtainPreProgressExecuteCycleStageIdComReqDto.getTargetCycleContentId(), "D3执行回写目标内容子周期执行周期阶段(公共)-D3获取上一个过程或子周期执行周期阶段ID(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(obtainPreProgressExecuteCycleStageIdComReqDto.getEvaluationTemplateId(), "D3执行回写目标内容子周期执行周期阶段(公共)-D3获取上一个过程或子周期执行周期阶段ID(公共)-冗余评价模板ID不能为空", false);
                    obtainPreProgressExecuteCycleStageIdComRespDto = obtainPreProgressExecuteCycleStageIdCom(obtainPreProgressExecuteCycleStageIdComReqDto)/*vcase invoke 同服务,同domain*/;


                }
                CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
                if (omsExecuteCycleStage != null && omsExecuteCycleStage_2 != null) {
                    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
                    if (omsExecuteCycleStage != null) {
                        checkTimeScopeSearchComReqDto.setCurrentTime(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:1923347_1_71369
                    }
                    if (omsExecuteCycleStage_2 != null) {
                        checkTimeScopeSearchComReqDto.setCompareTime(omsExecuteCycleStage_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1923349_1_71369
                    }

                    /*D2两个时间对比大小(公共)[3297]   */
                    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
                    Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
                    checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
                if (omsExecuteCycleStage != null && omsExecuteCycleStage_2 != null) {
                    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1 = new CheckTimeScopeSearchComReqDto();
                    if (omsExecuteCycleStage != null) {
                        checkTimeScopeSearchComReqDto_1.setCurrentTime(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:1923347_1_71370
                    }
                    if (omsExecuteCycleStage_2 != null) {
                        checkTimeScopeSearchComReqDto_1.setCompareTime(omsExecuteCycleStage_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1923349_1_71370
                    }

                    /*D2两个时间对比大小(公共)[3297]   */
                    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
                    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
                    checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT") && checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT"))) {
                    //if((D2目标内容的周期开始时间与目标的周期开始时间对比.时间比较结果 等于 当前（等于） and D2目标内容的周期结束时间与目标的周期结束时间对比.时间比较结果 等于 当前（等于）))  71371

                    boolean bOOLEAN;
                    if (omsExecuteCycleStage != null && obtainPreProgressExecuteCycleStageIdComRespDto != null && omsExecuteCycleStage_2 != null) {
                        OmsExecuteCycleStage omsExecuteCycleStage_4 = new OmsExecuteCycleStage();
                        if (omsExecuteCycleStage != null) {
                            omsExecuteCycleStage_4.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1730786_1_71372
                        }
                        if (obtainPreProgressExecuteCycleStageIdComRespDto != null) {
                            omsExecuteCycleStage_4.setLastExecuteCycleStageId(obtainPreProgressExecuteCycleStageIdComRespDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1730787_1_71372
                        }
                        if (omsExecuteCycleStage_2 != null) {
                            omsExecuteCycleStage_4.setFillStartTime(omsExecuteCycleStage_2.getFillStartTime());//SimpleFieldAssign//sourceId:1923350_1_71372
                            omsExecuteCycleStage_4.setFillEndtTime(omsExecuteCycleStage_2.getFillEndtTime());//SimpleFieldAssign//sourceId:1923351_1_71372
                            omsExecuteCycleStage_4.setEvaluateStartTime(omsExecuteCycleStage_2.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1923352_1_71372
                            omsExecuteCycleStage_4.setEvaluateEndtTime(omsExecuteCycleStage_2.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1923353_1_71372
                            omsExecuteCycleStage_4.setIsCurrentCycle(omsExecuteCycleStage_2.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1730793_1_71372
                            omsExecuteCycleStage_4.setIsNextCycle(omsExecuteCycleStage_2.getIsNextCycle());//SimpleFieldAssign//sourceId:1730795_1_71372
                            omsExecuteCycleStage_4.setIsStartCycle(omsExecuteCycleStage_2.getIsStartCycle());//SimpleFieldAssign//sourceId:1730794_1_71372
                            omsExecuteCycleStage_4.setIsEndCycle(omsExecuteCycleStage_2.getIsEndCycle());//SimpleFieldAssign//sourceId:1730796_1_71372
                            omsExecuteCycleStage_4.setIsLastCycle(omsExecuteCycleStage_2.getIsLastCycle());//SimpleFieldAssign//sourceId:1730797_1_71372
                            omsExecuteCycleStage_4.setNextCyclePeriod(omsExecuteCycleStage_2.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1730798_1_71372
                        }

                        /*3-3-07修改执行周期阶段[2489]   */
                        Assert.isNull(omsExecuteCycleStage_4.getExecuteCycleStageId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_4.getIsCurrentCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级/子周期当前不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_4.getIsNextCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级/子周期下一个不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_4.getIsStartCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否开始子周期不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_4.getIsEndCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否截止子周期不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_4.getIsLastCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级周期不能为空", false);
                        bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;


                    }
                } else if ((!(checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")) || !(checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))) {
                    //elseif((D2目标内容的周期开始时间与目标的周期开始时间对比.时间比较结果 不等于 当前（等于） or D2目标内容的周期结束时间与目标的周期结束时间对比.时间比较结果 不等于 当前（等于）))  71373

                    boolean bOOLEAN_1;
                    if (omsExecuteCycleStage != null && obtainPreProgressExecuteCycleStageIdComRespDto != null && omsExecuteCycleStage_2 != null) {
                        OmsExecuteCycleStage omsExecuteCycleStage_5 = new OmsExecuteCycleStage();
                        if (omsExecuteCycleStage != null) {
                            omsExecuteCycleStage_5.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1730786_1_71374
                        }
                        if (obtainPreProgressExecuteCycleStageIdComRespDto != null) {
                            omsExecuteCycleStage_5.setLastExecuteCycleStageId(obtainPreProgressExecuteCycleStageIdComRespDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1730787_1_71374
                        }
                        if (omsExecuteCycleStage_2 != null) {
                            omsExecuteCycleStage_5.setIsCurrentCycle(omsExecuteCycleStage_2.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1730793_1_71374
                            omsExecuteCycleStage_5.setIsNextCycle(omsExecuteCycleStage_2.getIsNextCycle());//SimpleFieldAssign//sourceId:1730795_1_71374
                            omsExecuteCycleStage_5.setIsStartCycle(omsExecuteCycleStage_2.getIsStartCycle());//SimpleFieldAssign//sourceId:1730794_1_71374
                            omsExecuteCycleStage_5.setIsEndCycle(omsExecuteCycleStage_2.getIsEndCycle());//SimpleFieldAssign//sourceId:1730796_1_71374
                            omsExecuteCycleStage_5.setIsLastCycle(omsExecuteCycleStage_2.getIsLastCycle());//SimpleFieldAssign//sourceId:1730797_1_71374
                            omsExecuteCycleStage_5.setNextCyclePeriod(omsExecuteCycleStage_2.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1730798_1_71374
                        }

                        /*3-3-07修改执行周期阶段[2489]   */
                        Assert.isNull(omsExecuteCycleStage_5.getExecuteCycleStageId(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_5.getIsCurrentCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级/子周期当前不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_5.getIsNextCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级/子周期下一个不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_5.getIsStartCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否开始子周期不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_5.getIsEndCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否截止子周期不能为空", false);
                        Assert.isNull(omsExecuteCycleStage_5.getIsLastCycle(), "D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级周期不能为空", false);
                        bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_5)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
//ModelCode: circulationEnd
            }

        } else if ((queryEvaObjTargetCycleListComRespDto != null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() != null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().size() == 0)) {
            //elseif(D3-3查询被评对象目标周期列表-子周期.被评对象目标周期列表数据集条数 等于 0)  69033

            ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto_3 = null;
            if (queryEvaObjTargetCycleListComRespDto != null) {
                ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto_3 = new ImplementDebugBusinessDataRedisComReqDto();
                implementDebugBusinessDataRedisComReqDto_3.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1816920_1_69044
                if (receptionServiceRes != null) {
                    implementDebugBusinessDataRedisComReqDto_3.setDebugScene(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1816933_1_69044
                    implementDebugBusinessDataRedisComReqDto_3.setWrongObjectDescribe(receptionServiceRes.getCustomField4());//SimpleFieldAssign//sourceId:1816934_1_69044
                    implementDebugBusinessDataRedisComReqDto_3.setCustomField2(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1817347_1_69044
                }
                if (reqDto != null) {
                    implementDebugBusinessDataRedisComReqDto_3.setCustomField3(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817348_1_69044
                    implementDebugBusinessDataRedisComReqDto_3.setCustomField4(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817349_1_69044
                    implementDebugBusinessDataRedisComReqDto_3.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817350_1_69044
                    implementDebugBusinessDataRedisComReqDto_3.setCustomField7(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817352_1_69044
                    implementDebugBusinessDataRedisComReqDto_3.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817351_1_69044
                }
                if (queryEvaObjTargetCycleListComRespDto != null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList())) {
                    implementDebugBusinessDataRedisComReqDto_3.setBusinessDataSetList(queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item -> item.getEvaObjTargetCycleId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:1816932_1_69044
                }

                /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
                Assert.isNull(implementDebugBusinessDataRedisComReqDto_3.getBusinessDataObject(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空", false);
                Assert.isNull(implementDebugBusinessDataRedisComReqDto_3.getDebugScene(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空", false);
                Assert.isNull(implementDebugBusinessDataRedisComReqDto_3.getWrongObjectDescribe(), "D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空", false);
                implementDebugBusinessDataRedisComRespDto_3 = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
        ImplementTargetConSubExecuteCycleStageComRespDto retData = new ImplementTargetConSubExecuteCycleStageComRespDto();
        if (queryEvaObjTargetCycleListComRespDto_1 != null) {
            retData.setEvaObjTargetCycleList(queryEvaObjTargetCycleListComRespDto_1.getEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1731351_1
        }


        return retData;
    }

    /**
     * D3更新目标内容父中周期执行周期阶段(公共)[9393]
     * gen by moon at 5/27/2024, 10:31:20 PM
     */
    @Trace(operationName = "D3更新目标内容父中周期执行周期阶段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public RefreshTargetConParentAndMidExecuteCycleStageComRespDto refreshTargetConParentAndMidExecuteCycleStageCom(RefreshTargetConParentAndMidExecuteCycleStageComReqDto reqDto) {


        OmsExecuteCycleStage omsExecuteCycleStage_1 = null;
        QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto_1 = null;
        //virtualUsage 3-3-07查询中期/父周期执行周期阶段详情  66872
        OmsExecuteCycleStage omsExecuteCycleStage = null;
        QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
        queryExecuteCycleStageDetailReq.setIsProcessCycleStage("FALSE");//sourceId:1732758_1_66872
        if (reqDto != null) {
            queryExecuteCycleStageDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1730665_1_66872
            queryExecuteCycleStageDetailReq.setIsFatherCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1731326_1_66872
            queryExecuteCycleStageDetailReq.setIsFatherCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1731326_1_66872
            queryExecuteCycleStageDetailReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1730666_1_66872
            queryExecuteCycleStageDetailReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1732589_1_66872
            queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1730667_1_66872
        }

        /*3-3-07查询中期/父周期执行周期阶段详情[2429]   */
        Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询中期/父周期执行周期阶段详情-关联目标内容ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getIsSubCycle(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询中期/父周期执行周期阶段详情-是否子周期不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询中期/父周期执行周期阶段详情-是否过程周期阶段不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询中期/父周期执行周期阶段详情-评价模板ID不能为空", false);
        omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsExecuteCycleStage_1 = omsExecuteCycleStage;
//virtualUsage D3查询父或中目标周期详请(公共)  67090
        QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
        if (omsExecuteCycleStage != null) {
            QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
            queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1737528_1_67090
            if (omsExecuteCycleStage != null) {
                queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(omsExecuteCycleStage.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1737527_1_67090
            }
            if (reqDto != null) {
                queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737529_1_67090
            }

            /*D3查询父或中目标周期详请(公共)[8528]   */
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中目标周期详请(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中目标周期详请(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中目标周期详请(公共)-是否存档不能为空", false);
            queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;


            queryEvaObjTargetCyclePlatformDetailComRespDto_1 = queryEvaObjTargetCyclePlatformDetailComRespDto;
        }
        if ((omsExecuteCycleStage != null)) {
            //if(3-3-07查询中期/父周期执行周期阶段详情.出参 值不等于空 )  66877

            QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto_2 = null;
            if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto_1 = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
                queryEvaObjTargetCyclePlatformDetailComReqDto_1.setIsSubCycle("TRUE");//sourceId:1737602_1_67091
                queryEvaObjTargetCyclePlatformDetailComReqDto_1.setIsArchive("FALSE");//sourceId:1737603_1_67091
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1737598_1_67091
                    queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1737599_1_67091
                    queryEvaObjTargetCyclePlatformDetailComReqDto_1.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1737601_1_67091
                }
                if (reqDto != null) {
                    queryEvaObjTargetCyclePlatformDetailComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1737600_1_67091
                    queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737604_1_67091
                }

                /*D3查询父或中结束时间匹配的目标子周期[8528]   */
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaObjEntityId(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaObjTypeCode(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-被评对象类型编码不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getTargetCycleContentId(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-关联目标内容ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getCycleEndTime(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-目标计划结束时间不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getIsSubCycle(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-是否子周期不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getIsArchive(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-是否存档不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaluationTemplateId(), "D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-冗余评价模板ID不能为空", false);
                queryEvaObjTargetCyclePlatformDetailComRespDto_2 = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto_1)/*vcase invoke isSameApp*/;


            }
            OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
            if (queryEvaObjTargetCyclePlatformDetailComRespDto_2 != null) {
                QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1 = new QueryExecuteCycleStageDetailReq();
                queryExecuteCycleStageDetailReq_1.setIsSubCycle("TRUE");//sourceId:1730967_1_66878
                queryExecuteCycleStageDetailReq_1.setIsProcessCycleStage("FALSE");//sourceId:1732760_1_66878
                queryExecuteCycleStageDetailReq_1.setIsArchive("FALSE");//sourceId:1732759_1_66878
                if (queryEvaObjTargetCyclePlatformDetailComRespDto_2 != null) {
                    queryExecuteCycleStageDetailReq_1.setEvaObjTargetCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1737608_1_66878
                }
                if (reqDto != null) {
                    queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1730968_1_66878
                }

                /*3-3-07查询执行周期阶段详情[2429]   */
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaObjTargetCycleId(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsSubCycle(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否子周期不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsProcessCycleStage(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsArchive(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
                Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
                omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;
                Assert.isTrue(omsExecuteCycleStage_2 == null || omsExecuteCycleStage_2.getExecuteCycleStageId() == null, "找不到数据，系统异常", false);


            }
            if ((omsExecuteCycleStage_2 == null)) {
                //if(3-3-07查与中期/父周期结束时间相同的子周期执行周期详情.出参 值等于空 )  69049

                ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto = new ImplementDebugBusinessDataRedisComReqDto();
                    implementDebugBusinessDataRedisComReqDto.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1817332_1_69050
                    implementDebugBusinessDataRedisComReqDto.setDebugScene("SINGLE_OBJECT");//CUSTOM_CONVENTION//sourceId:1817345_1_69050
                    implementDebugBusinessDataRedisComReqDto.setWrongObjectDescribe("对不起，找不到当前目标内容父或中自定义执行周期阶段~");//CUSTOM_CONVENTION//sourceId:1817346_1_69050
                    implementDebugBusinessDataRedisComReqDto.setCustomField2("refreshTargetConParentAndMidExecuteCycleStageCom");//CUSTOM_CONVENTION//sourceId:1817354_1_69050
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        implementDebugBusinessDataRedisComReqDto.setCustomField3(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817355_1_69050
                        implementDebugBusinessDataRedisComReqDto.setCustomField4(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817356_1_69050
                    }
                    if (reqDto != null) {
                        implementDebugBusinessDataRedisComReqDto.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817357_1_69050
                        implementDebugBusinessDataRedisComReqDto.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817358_1_69050
                    }

                    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getBusinessDataObject(), "D3更新目标内容父中周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空", false);
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getDebugScene(), "D3更新目标内容父中周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空", false);
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getWrongObjectDescribe(), "D3更新目标内容父中周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空", false);
                    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getCustomField2(), "D3更新目标内容父中周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-接口地址不能为空", false);
                    implementDebugBusinessDataRedisComRespDto = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
            }
            boolean bOOLEAN;
            if (omsExecuteCycleStage != null && omsExecuteCycleStage_2 != null) {
                OmsExecuteCycleStage omsExecuteCycleStage_4 = new OmsExecuteCycleStage();
                if (omsExecuteCycleStage != null) {
                    omsExecuteCycleStage_4.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1731256_1_66880
                }
                if (omsExecuteCycleStage_2 != null) {
                    omsExecuteCycleStage_4.setFillStartTime(omsExecuteCycleStage_2.getFillStartTime());//SimpleFieldAssign//sourceId:1731257_1_66880
                    omsExecuteCycleStage_4.setFillEndtTime(omsExecuteCycleStage_2.getFillEndtTime());//SimpleFieldAssign//sourceId:1731258_1_66880
                    omsExecuteCycleStage_4.setEvaluateStartTime(omsExecuteCycleStage_2.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1731259_1_66880
                    omsExecuteCycleStage_4.setEvaluateEndtTime(omsExecuteCycleStage_2.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1731260_1_66880
                }
                if (reqDto != null) {
                    omsExecuteCycleStage_4.setNextCyclePeriod(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1731261_1_66880
                }

                /*3-3-07修改执行周期阶段[2489]   */
                Assert.isNull(omsExecuteCycleStage_4.getExecuteCycleStageId(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                Assert.isNull(omsExecuteCycleStage_4.getFillStartTime(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-填报开始时间不能为空", false);
                Assert.isNull(omsExecuteCycleStage_4.getFillEndtTime(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-填报结束时间不能为空", false);
                Assert.isNull(omsExecuteCycleStage_4.getEvaluateStartTime(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-评价开始时间不能为空", false);
                Assert.isNull(omsExecuteCycleStage_4.getEvaluateEndtTime(), "D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-评价结束时间不能为空", false);
                bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
        RefreshTargetConParentAndMidExecuteCycleStageComRespDto retData = new RefreshTargetConParentAndMidExecuteCycleStageComRespDto();
        if (omsExecuteCycleStage_1 != null) {
            retData.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1732761_1
        }
        if (queryEvaObjTargetCyclePlatformDetailComRespDto_1 != null) {
            retData.setCycleStartTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1737610_1
            retData.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1737611_1
        }


        return retData;
    }

    /**
     * D3执行回删自定义执行周期(公共)[9449]
     * gen by moon at 4/28/2024, 2:33:55 PM
     */
    @Trace(operationName = "D3执行回删自定义执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementOverwriteDelCustomExeCycleComRespDto implementOverwriteDelCustomExeCycleCom(ImplementOverwriteDelCustomExeCycleComReqDto reqDto) {


        if ((reqDto != null && reqDto.getEvaObjTargetCycleList() != null && reqDto.getEvaObjTargetCycleList().size() > 0)) {
            //if(D3执行回删自定义执行周期(公共).被评对象目标周期列表数据集条数 大于 0)  67505

//ModelCode: circulationCollections
            for (EvaObjTargetCycleDto circulationCollectionsRes : reqDto.getEvaObjTargetCycleList()) {

                QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
                QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
                queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1755366_1_67508
                if (circulationCollectionsRes != null) {
                    queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755365_1_67508
                }
                if (reqDto != null) {
                    queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755367_1_67508
                }

                /*D3查当前子周期牌目标计划开始时间与结束时间[8528]   */
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(), "D3执行回删自定义执行周期(公共)-D3查当前子周期牌目标计划开始时间与结束时间-被评对象目标周期ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(), "D3执行回删自定义执行周期(公共)-D3查当前子周期牌目标计划开始时间与结束时间-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(), "D3执行回删自定义执行周期(公共)-D3查当前子周期牌目标计划开始时间与结束时间-是否存档不能为空", false);
                queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;


                CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
                    if (circulationCollectionsRes != null) {
                        checkTimeScopeSearchComReqDto.setCurrentTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1755353_1_67509
                    }
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        checkTimeScopeSearchComReqDto.setCompareTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1755355_1_67509
                    }

                    /*D2两个时间对比大小(公共)[3297]   */
                    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3执行回删自定义执行周期(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
                    Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3执行回删自定义执行周期(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
                    checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1 = new CheckTimeScopeSearchComReqDto();
                    if (circulationCollectionsRes != null) {
                        checkTimeScopeSearchComReqDto_1.setCurrentTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1755353_1_67510
                    }
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        checkTimeScopeSearchComReqDto_1.setCompareTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1755355_1_67510
                    }

                    /*D2两个时间对比大小(公共)[3297]   */
                    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(), "D3执行回删自定义执行周期(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
                    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(), "D3执行回删自定义执行周期(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
                    checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                if ((!(checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")))) {
                    //if(D2子周期成果汇报开始时间与目标计划开始时间对比（A）.时间比较结果 不等于 当前（等于）)  67511

                    boolean bOOLEAN;
                    OmsTargetCyclePlanSet omsTargetCyclePlanSet = new OmsTargetCyclePlanSet();
                    if (circulationCollectionsRes != null) {
                        omsTargetCyclePlanSet.setTargetCyclePlanSetId(circulationCollectionsRes.getTargetCyclePlanSetId());//SimpleFieldAssign//sourceId:1756857_1_67573
                        omsTargetCyclePlanSet.setTargetActualStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1756860_1_67573
                    }

                    /*3-3-08修改目标周期规划设置[6293]   */
                    Assert.isNull(omsTargetCyclePlanSet.getTargetCyclePlanSetId(), "D3执行回删自定义执行周期(公共)-3-3-08修改目标周期规划设置-目标周期规划设置ID不能为空", false);
                    bOOLEAN = mOmsTargetCyclePlanSetService.updateTargetCyclePset(omsTargetCyclePlanSet)/*vcase invoke 本地 method 方法调用;*/;


                    List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        QueryExecuteCycleGreaterAndEqualStartListReq queryExecuteCycleGreaterAndEqualStartListReq = new QueryExecuteCycleGreaterAndEqualStartListReq();
                        queryExecuteCycleGreaterAndEqualStartListReq.setIsProcessCycleStage("TRUE");//sourceId:1755386_1_67512
                        queryExecuteCycleGreaterAndEqualStartListReq.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1755387_1_67512
                        queryExecuteCycleGreaterAndEqualStartListReq.setIsArchive("FALSE");//sourceId:1755388_1_67512
                        if (circulationCollectionsRes != null) {
                            queryExecuteCycleGreaterAndEqualStartListReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755391_1_67512
                            queryExecuteCycleGreaterAndEqualStartListReq.setCycleEndTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1755393_1_67512
                        }
                        if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                            queryExecuteCycleGreaterAndEqualStartListReq.setCycleStartTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1755392_1_67512
                        }
                        if (reqDto != null) {
                            queryExecuteCycleGreaterAndEqualStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755389_1_67512
                        }

                        /*3-3-07-查询执行周期列表（开始大于等于&结束小于）[6660]   */
                        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getEvaObjTargetCycleId(), "D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-被评对象目标周期ID不能为空", false);
                        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getCycleStartTime(), "D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-周期开始时间不能为空", false);
                        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getCycleEndTime(), "D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-周期结束时间不能为空", false);
                        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getEvaluationTemplateId(), "D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-评价模板ID不能为空", false);
                        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsProcessCycleStage(), "D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否过程周期阶段不能为空", false);
                        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsDefinedExecuteCycleStage(), "D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否自定义执行周期阶段不能为空", false);
                        Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsArchive(), "D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否存档不能为空", false);
                        listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleGreaterAndEqualStartList(queryExecuteCycleGreaterAndEqualStartListReq)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    boolean bOOLEAN_1;
                    if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
                        List<String> listString = new ArrayList<>();
                        if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                            listString = listOmsExecuteCycleStage.stream().map(item -> item.getExecuteCycleStageId())
                                    .collect(Collectors.toList());/*list-to-strings*///sourceId:1755385_1_67513
                        }

                        /*3-3-07批量删执行周期阶段[2743]   */

                        bOOLEAN_1 = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch = new ArrayList<>();
                    if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
                        BatchQueryTimerTaskPlanReq batchQueryTimerTaskPlanReq = new BatchQueryTimerTaskPlanReq();
                        batchQueryTimerTaskPlanReq.setDispatchActionTypeCode("DISPATCH_ADD_REPORT_TASK");//sourceId:1755949_1_67532
                        batchQueryTimerTaskPlanReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1755950_1_67532
                        if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                            batchQueryTimerTaskPlanReq.setTimerTaskPlanList(listOmsExecuteCycleStage.stream().map(item -> item.getExecuteCycleStageId())
                                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:1755948_1_67532
                        }
                        if (reqDto != null) {
                            batchQueryTimerTaskPlanReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755960_1_67532
                        }

                        /*3-2-09批量查询定时任务调度[3531]   */
                        Assert.isNull(batchQueryTimerTaskPlanReq.getDispatchActionTypeCode(), "D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-任务调度的行为类型编码不能为空", false);
                        Assert.isNull(batchQueryTimerTaskPlanReq.getTaskDispatchTypeCode(), "D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-任务调度类型编码不能为空", false);
                        Assert.isNull(batchQueryTimerTaskPlanReq.getThemeContentId(), "D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-主题内容ID不能为空", false);
                        listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.batchQueryTimerTaskPlan(batchQueryTimerTaskPlanReq)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    boolean bOOLEAN_2;
                    if (listOmsTargetTimingTaskDispatch != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch) && listOmsTargetTimingTaskDispatch.size() > 0) {
                        List<String> listString_1 = new ArrayList<>();
                        if (listOmsTargetTimingTaskDispatch != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch) && listOmsTargetTimingTaskDispatch != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)) {
                            listString_1 = listOmsTargetTimingTaskDispatch.stream().map(item -> item.getTimingTaskDispatchId())
                                    .collect(Collectors.toList());/*list-to-strings*///sourceId:1755958_1_67533
                        }

                        /*3-2-09批量删定时任务调度[3277]   */

                        bOOLEAN_2 = mOmsTargetTimingTaskDispatchService.batchDeleteTimerTaskPlan(listString_1)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
                if ((!(checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))) {
                    //if(D2子周期成果汇报结束时间与目标计划结束时间对比（B）.时间比较结果 不等于 当前（等于）)  67515

                    boolean bOOLEAN_3;
                    OmsTargetCyclePlanSet omsTargetCyclePlanSet_1 = new OmsTargetCyclePlanSet();
                    if (circulationCollectionsRes != null) {
                        omsTargetCyclePlanSet_1.setTargetCyclePlanSetId(circulationCollectionsRes.getTargetCyclePlanSetId());//SimpleFieldAssign//sourceId:1756857_1_67574
                        omsTargetCyclePlanSet_1.setTargetActualEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1756861_1_67574
                        omsTargetCyclePlanSet_1.setAcceptancePlanTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1756862_1_67574
                    }

                    /*3-3-08修改目标周期规划设置[6293]   */
                    Assert.isNull(omsTargetCyclePlanSet_1.getTargetCyclePlanSetId(), "D3执行回删自定义执行周期(公共)-3-3-08修改目标周期规划设置-目标周期规划设置ID不能为空", false);
                    bOOLEAN_3 = mOmsTargetCyclePlanSetService.updateTargetCyclePset(omsTargetCyclePlanSet_1)/*vcase invoke 本地 method 方法调用;*/;


                    List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 = new ArrayList<>();
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        QueryTimeMatchExecCycleList2Req queryTimeMatchExecCycleList2Req = new QueryTimeMatchExecCycleList2Req();
                        queryTimeMatchExecCycleList2Req.setIsProcessCycleStage("TRUE");//sourceId:1755398_1_67517
                        queryTimeMatchExecCycleList2Req.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1755406_1_67517
                        if (circulationCollectionsRes != null) {
                            queryTimeMatchExecCycleList2Req.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755409_1_67517
                            queryTimeMatchExecCycleList2Req.setCycleStartTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1755395_1_67517
                        }
                        if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                            queryTimeMatchExecCycleList2Req.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1755396_1_67517
                        }
                        if (reqDto != null) {
                            queryTimeMatchExecCycleList2Req.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755402_1_67517
                        }

                        /*3-3-07时间匹配执行周期列表（开始大于&结束小于等于）[6321]   */
                        Assert.isNull(queryTimeMatchExecCycleList2Req.getEvaObjTargetCycleId(), "D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-被评对象目标周期ID不能为空", false);
                        Assert.isNull(queryTimeMatchExecCycleList2Req.getCycleStartTime(), "D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-周期开始时间不能为空", false);
                        Assert.isNull(queryTimeMatchExecCycleList2Req.getCycleEndTime(), "D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-周期结束时间不能为空", false);
                        Assert.isNull(queryTimeMatchExecCycleList2Req.getEvaluationTemplateId(), "D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-评价模板ID不能为空", false);
                        Assert.isNull(queryTimeMatchExecCycleList2Req.getIsProcessCycleStage(), "D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-是否过程周期阶段不能为空", false);
                        Assert.isNull(queryTimeMatchExecCycleList2Req.getIsDefinedExecuteCycleStage(), "D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-是否自定义执行周期阶段不能为空", false);
                        listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryTimeMatchExecCycleList2(queryTimeMatchExecCycleList2Req)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    boolean bOOLEAN_4;
                    if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2.size() > 0) {
                        List<String> listString_2 = new ArrayList<>();
                        if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)) {
                            listString_2 = listOmsExecuteCycleStage_2.stream().map(item -> item.getExecuteCycleStageId())
                                    .collect(Collectors.toList());/*list-to-strings*///sourceId:1755385_1_67516
                        }

                        /*3-3-07批量删执行周期阶段[2743]   */

                        bOOLEAN_4 = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString_2)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch_2 = new ArrayList<>();
                    if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2.size() > 0) {
                        BatchQueryTimerTaskPlanReq batchQueryTimerTaskPlanReq_1 = new BatchQueryTimerTaskPlanReq();
                        batchQueryTimerTaskPlanReq_1.setDispatchActionTypeCode("DISPATCH_ADD_REPORT_TASK");//sourceId:1755949_1_67534
                        batchQueryTimerTaskPlanReq_1.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1755950_1_67534
                        if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)) {
                            batchQueryTimerTaskPlanReq_1.setTimerTaskPlanList(listOmsExecuteCycleStage_2.stream().map(item -> item.getExecuteCycleStageId())
                                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:1755948_1_67534
                        }
                        if (reqDto != null) {
                            batchQueryTimerTaskPlanReq_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755960_1_67534
                        }

                        /*3-2-09批量查询定时任务调度[3531]   */
                        Assert.isNull(batchQueryTimerTaskPlanReq_1.getDispatchActionTypeCode(), "D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-任务调度的行为类型编码不能为空", false);
                        Assert.isNull(batchQueryTimerTaskPlanReq_1.getTaskDispatchTypeCode(), "D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-任务调度类型编码不能为空", false);
                        Assert.isNull(batchQueryTimerTaskPlanReq_1.getThemeContentId(), "D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-主题内容ID不能为空", false);
                        listOmsTargetTimingTaskDispatch_2 = mOmsTargetTimingTaskDispatchService.batchQueryTimerTaskPlan(batchQueryTimerTaskPlanReq_1)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    boolean bOOLEAN_5;
                    if (listOmsTargetTimingTaskDispatch_2 != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch_2) && listOmsTargetTimingTaskDispatch_2.size() > 0) {
                        List<String> listString_3 = new ArrayList<>();
                        if (listOmsTargetTimingTaskDispatch_2 != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch_2) && listOmsTargetTimingTaskDispatch_2 != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch_2)) {
                            listString_3 = listOmsTargetTimingTaskDispatch_2.stream().map(item -> item.getTimingTaskDispatchId())
                                    .collect(Collectors.toList());/*list-to-strings*///sourceId:1755958_1_67535
                        }

                        /*3-2-09批量删定时任务调度[3277]   */

                        bOOLEAN_5 = mOmsTargetTimingTaskDispatchService.batchDeleteTimerTaskPlan(listString_3)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
//ModelCode: circulationEnd
            }

        }
        ImplementOverwriteDelCustomExeCycleComRespDto retData = new ImplementOverwriteDelCustomExeCycleComRespDto();


        return retData;
    }

    /**
     * D3回写目标内容父或中成果汇报时间(公共)[9450]
     * gen by moon at 4/27/2024, 2:18:11 AM
     */
    @Trace(operationName = "D3回写目标内容父或中成果汇报时间(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeCom(ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto reqDto) {


        //virtualUsage D3查询目标内容父或中目标周期详请  67525
        QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
        QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
        queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1755851_1_67525
        if (reqDto != null) {
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755924_1_67525
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755852_1_67525
        }

        /*D3查询目标内容父或中目标周期详请[8528]   */
        Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标内容父或中目标周期详请-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标内容父或中目标周期详请-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标内容父或中目标周期详请-是否存档不能为空", false);
        queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D3查询目标子周期规划设置详情(公共)  67527
        QueryTargetSubCyclePlanSetDetailComRespDto queryTargetSubCyclePlanSetDetailComRespDto = null;
        if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
            QueryTargetSubCyclePlanSetDetailComReqDto queryTargetSubCyclePlanSetDetailComReqDto = new QueryTargetSubCyclePlanSetDetailComReqDto();
            if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                queryTargetSubCyclePlanSetDetailComReqDto.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1755770_1_67527
                queryTargetSubCyclePlanSetDetailComReqDto.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1755771_1_67527
                queryTargetSubCyclePlanSetDetailComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1755772_1_67527
                queryTargetSubCyclePlanSetDetailComReqDto.setCycleStartTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1755773_1_67527
            }
            if (reqDto != null) {
                queryTargetSubCyclePlanSetDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755775_1_67527
            }

            /*D3查询目标子周期规划设置详情(公共)[6875]   */
            Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto.getEvaObjEntityId(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto.getEvaObjTypeCode(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-被评对象类型编码不能为空", false);
            Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto.getTargetCycleContentId(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto.getEvaluationTemplateId(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-冗余评价模板ID不能为空", false);
            queryTargetSubCyclePlanSetDetailComRespDto = targetCycleService.queryTargetSubCyclePlanSetDetailCom(queryTargetSubCyclePlanSetDetailComReqDto)/*vcase invoke isSameApp*/;


        }
//virtualUsage D3修改目标实际起止时间(公共)  67529
        UpdateTargetActualStartEndtTimeComRespDto updateTargetActualStartEndtTimeComRespDto = null;
        if (queryTargetSubCyclePlanSetDetailComRespDto != null) {
            UpdateTargetActualStartEndtTimeComReqDto updateTargetActualStartEndtTimeComReqDto = new UpdateTargetActualStartEndtTimeComReqDto();
            if (reqDto != null) {
                updateTargetActualStartEndtTimeComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755942_1_67529
                updateTargetActualStartEndtTimeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755945_1_67529
            }
            if (queryTargetSubCyclePlanSetDetailComRespDto != null) {
                updateTargetActualStartEndtTimeComReqDto.setTargetActualStartTime(queryTargetSubCyclePlanSetDetailComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1755943_1_67529
            }

            /*D3修改目标实际起止时间(公共)[6872]   */
            Assert.isNull(updateTargetActualStartEndtTimeComReqDto.getEvaObjTargetCycleId(), "D3回写目标内容父或中成果汇报时间(公共)-D3修改目标实际起止时间(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(updateTargetActualStartEndtTimeComReqDto.getEvaluationTemplateId(), "D3回写目标内容父或中成果汇报时间(公共)-D3修改目标实际起止时间(公共)-冗余评价模板ID不能为空", false);
            updateTargetActualStartEndtTimeComRespDto = targetCycleService.updateTargetActualStartEndtTimeCom(updateTargetActualStartEndtTimeComReqDto)/*vcase invoke isSameApp*/;


        }
//virtualUsage D3查询目标子周期规划设置详情(公共)  67530
        QueryTargetSubCyclePlanSetDetailComRespDto queryTargetSubCyclePlanSetDetailComRespDto_2 = null;
        if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
            QueryTargetSubCyclePlanSetDetailComReqDto queryTargetSubCyclePlanSetDetailComReqDto_1 = new QueryTargetSubCyclePlanSetDetailComReqDto();
            if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                queryTargetSubCyclePlanSetDetailComReqDto_1.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1755770_1_67530
                queryTargetSubCyclePlanSetDetailComReqDto_1.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1755771_1_67530
                queryTargetSubCyclePlanSetDetailComReqDto_1.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1755772_1_67530
                queryTargetSubCyclePlanSetDetailComReqDto_1.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1755774_1_67530
            }
            if (reqDto != null) {
                queryTargetSubCyclePlanSetDetailComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755775_1_67530
            }

            /*D3查询目标子周期规划设置详情(公共)[6875]   */
            Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto_1.getEvaObjEntityId(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto_1.getEvaObjTypeCode(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-被评对象类型编码不能为空", false);
            Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto_1.getTargetCycleContentId(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto_1.getEvaluationTemplateId(), "D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-冗余评价模板ID不能为空", false);
            queryTargetSubCyclePlanSetDetailComRespDto_2 = targetCycleService.queryTargetSubCyclePlanSetDetailCom(queryTargetSubCyclePlanSetDetailComReqDto_1)/*vcase invoke isSameApp*/;


        }
//virtualUsage D3修改目标实际起止时间(公共)  67531
        UpdateTargetActualStartEndtTimeComRespDto updateTargetActualStartEndtTimeComRespDto_1 = null;
        if (queryTargetSubCyclePlanSetDetailComRespDto_2 != null) {
            UpdateTargetActualStartEndtTimeComReqDto updateTargetActualStartEndtTimeComReqDto_1 = new UpdateTargetActualStartEndtTimeComReqDto();
            if (reqDto != null) {
                updateTargetActualStartEndtTimeComReqDto_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755942_1_67531
                updateTargetActualStartEndtTimeComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755945_1_67531
            }
            if (queryTargetSubCyclePlanSetDetailComRespDto_2 != null) {
                updateTargetActualStartEndtTimeComReqDto_1.setTargetActualEndtTime(queryTargetSubCyclePlanSetDetailComRespDto_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1755944_1_67531
            }

            /*D3修改目标实际起止时间(公共)[6872]   */
            Assert.isNull(updateTargetActualStartEndtTimeComReqDto_1.getEvaObjTargetCycleId(), "D3回写目标内容父或中成果汇报时间(公共)-D3修改目标实际起止时间(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(updateTargetActualStartEndtTimeComReqDto_1.getEvaluationTemplateId(), "D3回写目标内容父或中成果汇报时间(公共)-D3修改目标实际起止时间(公共)-冗余评价模板ID不能为空", false);
            updateTargetActualStartEndtTimeComRespDto_1 = targetCycleService.updateTargetActualStartEndtTimeCom(updateTargetActualStartEndtTimeComReqDto_1)/*vcase invoke isSameApp*/;


        }
        ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto retData = new ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto();


        return retData;
    }

    /**
     * D3回删目标内容汇报任务任务调度(公共)[9451]
     * gen by moon at 4/27/2024, 2:18:35 AM
     */
    @Trace(operationName = "D3回删目标内容汇报任务任务调度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementOverwriteDelTargetContReportTimerTaskPlanComRespDto implementOverwriteDelTargetContReportTimerTaskPlanCom(ImplementOverwriteDelTargetContReportTimerTaskPlanComReqDto reqDto) {


        //virtualUsage D3查询被评目标周期列表(公共)  67536
        QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto = null;
        QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto = new QueryEvaTargetCycleListComReqDto();
        queryEvaTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1756235_1_67536
        if (reqDto != null) {
            queryEvaTargetCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1756226_1_67536
            queryEvaTargetCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1756227_1_67536
            queryEvaTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756229_1_67536
            queryEvaTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756234_1_67536
        }

        /*D3查询被评目标周期列表(公共)[9416]   */
        Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjEntityId(), "D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjTypeCode(), "D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaTargetCycleListComReqDto.getTargetCycleContentId(), "D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaluationTemplateId(), "D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaTargetCycleListComReqDto.getIsArchive(), "D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-是否存档不能为空", false);
        queryEvaTargetCycleListComRespDto = targetContComService.queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


        if ((queryEvaTargetCycleListComRespDto != null && queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() != null && queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().size() > 0)) {
            //if(D3查询当前目标内容目标周期列表(公共).被评对象目标周期列表数据集条数 大于 0)  67538

            List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
            QueryExecuteCycleStageListReq queryExecuteCycleStageListReq = new QueryExecuteCycleStageListReq();
            queryExecuteCycleStageListReq.setRelateContentTypeCode("TARGET");//sourceId:1756325_1_67539
            queryExecuteCycleStageListReq.setIsArchive("FALSE");//sourceId:1756267_1_67539
            if (reqDto != null) {
                queryExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756266_1_67539
            }

            /*3-3-07查目标执行周期阶段列表[3201]   */
            Assert.isNull(queryExecuteCycleStageListReq.getEvaluationTemplateId(), "D3回删目标内容汇报任务任务调度(公共)-3-3-07查目标执行周期阶段列表-评价模板ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getRelateContentTypeCode(), "D3回删目标内容汇报任务任务调度(公共)-3-3-07查目标执行周期阶段列表-关联目标内容类型编码不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getIsArchive(), "D3回删目标内容汇报任务任务调度(公共)-3-3-07查目标执行周期阶段列表-是否存档不能为空", false);
            listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageList(queryExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: circulationCollections
            for (EvaObjTargetCycleDto circulationCollectionsRes : queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList()) {

                List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch = new ArrayList<>();
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
                    BatchQueryTimerTaskPlanReq batchQueryTimerTaskPlanReq = new BatchQueryTimerTaskPlanReq();
                    batchQueryTimerTaskPlanReq.setDispatchActionTypeCode("DISPATCH_ADD_REPORT_TASK");//sourceId:1756314_1_67542
                    batchQueryTimerTaskPlanReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1756315_1_67542
                    if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                        batchQueryTimerTaskPlanReq.setTimerTaskPlanList(listOmsExecuteCycleStage.stream().map(item -> item.getExecuteCycleStageId())
                                .collect(Collectors.toList()));/*list-to-strings*///sourceId:1756313_1_67542
                    }
                    if (circulationCollectionsRes != null) {
                        batchQueryTimerTaskPlanReq.setObjectId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1756317_1_67542
                    }
                    if (reqDto != null) {
                        batchQueryTimerTaskPlanReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756323_1_67542
                    }

                    /*3-2-09批量查询定时任务调度[3531]   */
                    Assert.isNull(batchQueryTimerTaskPlanReq.getDispatchActionTypeCode(), "D3回删目标内容汇报任务任务调度(公共)-3-2-09批量查询定时任务调度-任务调度的行为类型编码不能为空", false);
                    Assert.isNull(batchQueryTimerTaskPlanReq.getTaskDispatchTypeCode(), "D3回删目标内容汇报任务任务调度(公共)-3-2-09批量查询定时任务调度-任务调度类型编码不能为空", false);
                    Assert.isNull(batchQueryTimerTaskPlanReq.getObjectId(), "D3回删目标内容汇报任务任务调度(公共)-3-2-09批量查询定时任务调度-归属对象内容ID不能为空", false);
                    Assert.isNull(batchQueryTimerTaskPlanReq.getThemeContentId(), "D3回删目标内容汇报任务任务调度(公共)-3-2-09批量查询定时任务调度-主题内容ID不能为空", false);
                    listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.batchQueryTimerTaskPlan(batchQueryTimerTaskPlanReq)/*vcase invoke 本地 method 方法调用;*/;


                }
                boolean bOOLEAN;
                if (listOmsTargetTimingTaskDispatch != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch) && listOmsTargetTimingTaskDispatch.size() > 0) {
                    List<String> listString = new ArrayList<>();
                    if (listOmsTargetTimingTaskDispatch != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch) && listOmsTargetTimingTaskDispatch != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)) {
                        listString = listOmsTargetTimingTaskDispatch.stream().map(item -> item.getTimingTaskDispatchId())
                                .collect(Collectors.toList());/*list-to-strings*///sourceId:1756324_1_67543
                    }

                    /*3-2-09批量删定时任务调度[3277]   */

                    bOOLEAN = mOmsTargetTimingTaskDispatchService.batchDeleteTimerTaskPlan(listString)/*vcase invoke 本地 method 方法调用;*/;


                }
//ModelCode: circulationEnd
            }

        }
        ImplementOverwriteDelTargetContReportTimerTaskPlanComRespDto retData = new ImplementOverwriteDelTargetContReportTimerTaskPlanComRespDto();


        return retData;
    }

    /**
     * D3分析回写目标内容自定义汇报(公共)[9452]
     * gen by moon at 4/27/2024, 2:18:51 AM
     */
    @Trace(operationName = "D3分析回写目标内容自定义汇报(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisOverwriteTargetContCustomReportComRespDto analysisOverwriteTargetContCustomReportCom(AnalysisOverwriteTargetContCustomReportComReqDto reqDto) {


        if ((reqDto != null && reqDto.getEvaObjTargetCycleList() != null && reqDto.getEvaObjTargetCycleList().size() > 0)) {
            //if(D3分析回写目标内容自定义汇报(公共).被评对象目标周期列表数据集条数 大于 0)  67558

//ModelCode: circulationCollections
            for (EvaObjTargetCycleDto circulationCollectionsRes : reqDto.getEvaObjTargetCycleList()) {

                QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
                QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
                queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1756845_1_67561
                if (circulationCollectionsRes != null) {
                    queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1756844_1_67561
                }
                if (reqDto != null) {
                    queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756846_1_67561
                }

                /*D3查当前子周期牌目标计划开始时间与结束时间[8528]   */
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(), "D3分析回写目标内容自定义汇报(公共)-D3查当前子周期牌目标计划开始时间与结束时间-被评对象目标周期ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(), "D3分析回写目标内容自定义汇报(公共)-D3查当前子周期牌目标计划开始时间与结束时间-冗余评价模板ID不能为空", false);
                Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(), "D3分析回写目标内容自定义汇报(公共)-D3查当前子周期牌目标计划开始时间与结束时间-是否存档不能为空", false);
                queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;


                CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
                    if (circulationCollectionsRes != null) {
                        checkTimeScopeSearchComReqDto.setCurrentTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1756841_1_67562
                    }
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        checkTimeScopeSearchComReqDto.setCompareTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1756843_1_67562
                    }

                    /*D2两个时间对比大小(公共)[3297]   */
                    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3分析回写目标内容自定义汇报(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
                    Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3分析回写目标内容自定义汇报(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
                    checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
                if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1 = new CheckTimeScopeSearchComReqDto();
                    if (circulationCollectionsRes != null) {
                        checkTimeScopeSearchComReqDto_1.setCurrentTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1756841_1_67563
                    }
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        checkTimeScopeSearchComReqDto_1.setCompareTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1756843_1_67563
                    }

                    /*D2两个时间对比大小(公共)[3297]   */
                    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(), "D3分析回写目标内容自定义汇报(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
                    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(), "D3分析回写目标内容自定义汇报(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
                    checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                if ((!(checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")) || !(checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))) {
                    //if((D2子周期成果汇报开始时间与目标计划开始时间对比（A）.时间比较结果 不等于 当前（等于） or D2子周期成果汇报结束时间与目标计划结束时间对比（B）.时间比较结果 不等于 当前（等于）))  67566

                    ImplementAmendTargetContIsCustomReportComRespDto implementAmendTargetContIsCustomReportComRespDto = null;
                    if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                        ImplementAmendTargetContIsCustomReportComReqDto implementAmendTargetContIsCustomReportComReqDto = new ImplementAmendTargetContIsCustomReportComReqDto();
                        implementAmendTargetContIsCustomReportComReqDto.setIsOpenCustomReport("TRUE");//sourceId:1756852_1_67571
                        if (queryEvaObjTargetCyclePlatformDetailComRespDto != null) {
                            implementAmendTargetContIsCustomReportComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1756849_1_67571
                            implementAmendTargetContIsCustomReportComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756850_1_67571
                        }
                        if (reqDto != null) {
                            implementAmendTargetContIsCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756851_1_67571
                        }

                        /*D3回写目标内容开启自定义汇报(公共)[6893]   */
                        Assert.isNull(implementAmendTargetContIsCustomReportComReqDto.getIsOpenCustomReport(), "D3分析回写目标内容自定义汇报(公共)-D3回写目标内容开启自定义汇报(公共)-是否开启自定义汇报不能为空", false);
                        Assert.isNull(implementAmendTargetContIsCustomReportComReqDto.getTargetCycleContentTypeCode(), "D3分析回写目标内容自定义汇报(公共)-D3回写目标内容开启自定义汇报(公共)-关联目标内容类型编码不能为空", false);
                        Assert.isNull(implementAmendTargetContIsCustomReportComReqDto.getTargetCycleContentId(), "D3分析回写目标内容自定义汇报(公共)-D3回写目标内容开启自定义汇报(公共)-关联目标内容ID不能为空", false);
                        Assert.isNull(implementAmendTargetContIsCustomReportComReqDto.getEvaluationTemplateId(), "D3分析回写目标内容自定义汇报(公共)-D3回写目标内容开启自定义汇报(公共)-冗余评价模板ID不能为空", false);
                        implementAmendTargetContIsCustomReportComRespDto = indexSystemService.implementAmendTargetContIsCustomReportCom(implementAmendTargetContIsCustomReportComReqDto)/*vcase invoke isSameApp*/;


                    }
                }
//ModelCode: circulationEnd
            }

        }
        AnalysisOverwriteTargetContCustomReportComRespDto retData = new AnalysisOverwriteTargetContCustomReportComRespDto();


        return retData;
    }

    /**
     * D3分析裁剪子周期汇报时间类型(公共)[9456]
     * gen by moon at 4/28/2024, 1:34:24 AM
     */
    @Trace(operationName = "D3分析裁剪子周期汇报时间类型(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisCutCycleReportTimeTypeCodeComRespDto analysisCutCycleReportTimeTypeCodeCom(AnalysisCutCycleReportTimeTypeCodeComReqDto reqDto) {


        ImplementFiveReceivingFieldRespDto receptionServiceRes_3 = null;
//virtualUsage M3约定裁剪子周期汇报时间类型  67622
        //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
        ImplementFiveReceivingFieldReqDto receptionServiceReq = new ImplementFiveReceivingFieldReqDto();
        receptionServiceReq.setCustomField1("LESS_THAN_YEAR");//CUSTOM_CONVENTION//sourceId:1760278_1_67622
        receptionServiceReq.setCustomField2("EQUAL_TO_YEAR");//CUSTOM_CONVENTION//sourceId:1760279_1_67622
        receptionServiceReq.setCustomField3("SPECIAL_SUB_CYCLE_TYPES");//CUSTOM_CONVENTION//sourceId:1760280_1_67622

        /*M3约定裁剪子周期汇报时间类型[8467]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D3分析裁剪子周期汇报时间类型(公共)-M3约定裁剪子周期汇报时间类型-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D3分析裁剪子周期汇报时间类型(公共)-M3约定裁剪子周期汇报时间类型-自定义字段2不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField3(), "D3分析裁剪子周期汇报时间类型(公共)-M3约定裁剪子周期汇报时间类型-自定义字段3不能为空", false);
        receptionServiceRes = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq);


//virtualUsage D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）  67619
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SPACE_CREATE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1760283_1_67619
        queryConfItemMatchAnswerDetailComReqDto.setConfSchemeCode("COM_CONF_SCHEME");//CUSTOM_CONVENTION//sourceId:1760284_1_67619
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:1760262_1_67619
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setConfOptionCode(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1760267_1_67619
        }

        /*D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfOptionCode(), "D3分析裁剪子周期汇报时间类型(公共)-D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）-选项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3分析裁剪子周期汇报时间类型(公共)-D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfSchemeCode(), "D3分析裁剪子周期汇报时间类型(公共)-D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）-配置方案标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3分析裁剪子周期汇报时间类型(公共)-D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getOptionResultId() != null)) {
            //if(D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）.答案ID 值不等于空 )  67620

//ModelCode: receptionService
            ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
            ImplementFiveReceivingFieldReqDto receptionServiceReq_1 = new ImplementFiveReceivingFieldReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setCutCycleReportTimeTypeCode(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1759912_1_67621
            }

            /*M3接收裁剪子周期汇报时间类型出参[8467]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getCutCycleReportTimeTypeCode(), "D3分析裁剪子周期汇报时间类型(公共)-M3接收裁剪子周期汇报时间类型出参-裁剪子周期汇报时间类型编码不能为空", false);
            receptionServiceRes_2 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getOptionResultId() == null)) {
            //elseif(D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）.答案ID 值等于空 )  67623

            if ((reqDto != null && reqDto.getSubcycleType() != null && reqDto.getSubcycleType().equals("YEAR"))) {
                //if(D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 年)  67626

//ModelCode: receptionService
                ImplementFiveReceivingFieldRespDto receptionServiceRes_4 = null;
                ImplementFiveReceivingFieldReqDto receptionServiceReq_2 = new ImplementFiveReceivingFieldReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_2.setCutCycleReportTimeTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1759912_1_67627
                }

                /*M3接收裁剪子周期汇报时间类型出参[8467]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getCutCycleReportTimeTypeCode(), "D3分析裁剪子周期汇报时间类型(公共)-M3接收裁剪子周期汇报时间类型出参-裁剪子周期汇报时间类型编码不能为空", false);
                receptionServiceRes_4 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_2);


                receptionServiceRes_3 = receptionServiceRes_4;
            } else if ((reqDto != null && reqDto.getSubcycleType() != null && reqDto.getSubcycleType().equals("HALF_YEAR") || reqDto != null && reqDto.getSubcycleType() != null && reqDto.getSubcycleType().equals("QUARTER") || reqDto != null && reqDto.getSubcycleType() != null && reqDto.getSubcycleType().equals("DOUBLE_MOONS") || reqDto != null && reqDto.getSubcycleType() != null && reqDto.getSubcycleType().equals("MONTH") || reqDto != null && reqDto.getSubcycleType() != null && reqDto.getSubcycleType().equals("DOUBLE_WEEKS"))) {
                //elseif((D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 半年 or D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 季度 or D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 双月 or D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 月 or D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 双周))  67628

//ModelCode: receptionService
                ImplementFiveReceivingFieldRespDto receptionServiceRes_5 = null;
                ImplementFiveReceivingFieldReqDto receptionServiceReq_3 = new ImplementFiveReceivingFieldReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_3.setCutCycleReportTimeTypeCode(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1759912_1_67629
                }

                /*M3接收裁剪子周期汇报时间类型出参[8467]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getCutCycleReportTimeTypeCode(), "D3分析裁剪子周期汇报时间类型(公共)-M3接收裁剪子周期汇报时间类型出参-裁剪子周期汇报时间类型编码不能为空", false);
                receptionServiceRes_5 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_3);


                receptionServiceRes_3 = receptionServiceRes_5;
            }
        }
        AnalysisCutCycleReportTimeTypeCodeComRespDto retData = new AnalysisCutCycleReportTimeTypeCodeComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setCutCycleReportTimeTypeCode(receptionServiceRes_3.getCutCycleReportTimeTypeCode());//SimpleFieldAssign//sourceId:1760292_1
        }


        return retData;
    }

    /**
     * D3查询自定义汇报工作周期列表(公共)[9458]
     * gen by moon at 4/28/2024, 2:34:16 PM
     */
    @Trace(operationName = "D3查询自定义汇报工作周期列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryCustomReportWorkCycleListComRespDto queryCustomReportWorkCycleListCom(QueryCustomReportWorkCycleListComReqDto reqDto) {


        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1761175_1
            receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1761174_1
            receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1761163_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761164_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaObjEntityId(), "D3查询自定义汇报工作周期列表(公共)-M3接收入参字段-被评对象内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjTypeCode(), "D3查询自定义汇报工作周期列表(公共)-M3接收入参字段-被评对象类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getTargetCycleContentId(), "D3查询自定义汇报工作周期列表(公共)-M3接收入参字段-关联目标内容ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3查询自定义汇报工作周期列表(公共)-M3接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbCustomExecutionCycle.implementEightReceivingField(receptionServiceReq);


//步骤1: 3-3-09查被评对象目标周期列表（根据周期时间范围） - queryEvaObjTargetCycleList
        List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
        QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq = new QueryEvaObjTargetCycleListReq();
        queryEvaObjTargetCycleListReq.setIsSubCycle("TRUE");//sourceId:1761170_1
        queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1761172_1
        if (reqDto != null) {
            queryEvaObjTargetCycleListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1761167_1
            queryEvaObjTargetCycleListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1761173_1
            queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1761169_1
            queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761171_1
        }

        /*3-3-09查目标子周期列表[2190]   */
        Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getIsSubCycle(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-是否子周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-是否存档不能为空", false);
        listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤2: 3-3-08批量查询目标周期规划设置 - batchQueryTargetCyclePset
        List<OmsTargetCyclePlanSet> listOmsTargetCyclePlanSet = new ArrayList<>();
        if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle.size() > 0) {
            BatchQueryTargetCyclePsetReq batchQueryTargetCyclePsetReq = new BatchQueryTargetCyclePsetReq();
            batchQueryTargetCyclePsetReq.setIsArchive("FALSE");//sourceId:1760998_1
            if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)) {
                batchQueryTargetCyclePsetReq.setTargetCyclePsetList(listOmsEvaluationObjectTargetCycle.stream().map(item -> item.getEvaObjTargetCycleId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1760995_1
            }
            if (reqDto != null) {
                batchQueryTargetCyclePsetReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1760996_1
                batchQueryTargetCyclePsetReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1760996_1
            }

            /*3-3-08批量查询目标周期规划设置[4120]   */
            Assert.isNull(batchQueryTargetCyclePsetReq.getEvaluationTemplateId(), "D3查询自定义汇报工作周期列表(公共)-3-3-08批量查询目标周期规划设置-冗余评价模板ID不能为空", false);
            Assert.isNull(batchQueryTargetCyclePsetReq.getEvaluationTemplateId(), "D3查询自定义汇报工作周期列表(公共)-3-3-08批量查询目标周期规划设置-冗余评价模板ID不能为空", false);
            Assert.isNull(batchQueryTargetCyclePsetReq.getIsArchive(), "D3查询自定义汇报工作周期列表(公共)-3-3-08批量查询目标周期规划设置-是否存档不能为空", false);
            listOmsTargetCyclePlanSet = mOmsTargetCyclePlanSetService.batchQueryTargetCyclePset(batchQueryTargetCyclePsetReq)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤3: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1761184_1
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1761186_1
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1761181_1
            queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1761182_1
            queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1761183_1
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761185_1
        }

        /*3-3-09查目标内容父周期ID[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-是否父周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤4: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq_1.setIsMetaphase("TRUE");//sourceId:1761531_1
        queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1761533_1
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1761528_1
            queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1761529_1
            queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1761530_1
            queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761532_1
        }

        /*3-3-09查目标内容中期ID[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsMetaphase(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-是否中期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(), "D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


//步骤5: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
        //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_1 = null;
        if (listOmsTargetCyclePlanSet != null && !CollectionUtil.isEmpty(listOmsTargetCyclePlanSet) && listOmsTargetCyclePlanSet.size() > 0) {
            ImplementFiveReceivingFieldReqDto receptionServiceReq_1 = new ImplementFiveReceivingFieldReqDto();
            if (listOmsTargetCyclePlanSet != null && !CollectionUtil.isEmpty(listOmsTargetCyclePlanSet) && listOmsTargetCyclePlanSet != null && !CollectionUtil.isEmpty(listOmsTargetCyclePlanSet)) {
                receptionServiceReq_1.setTargetContPlanWorkTimeList(listOmsTargetCyclePlanSet.stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1761537_1
            }
            if (omsEvaluationObjectTargetCycle != null) {
                receptionServiceReq_1.setTargetCycleParentCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1761543_1
            }
            if (omsEvaluationObjectTargetCycle_2 != null) {
                receptionServiceReq_1.setTargetCycleMidCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1761544_1
            }

            /*M3接收出参字段[8467]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getTargetCycleParentCycleId(), "D3查询自定义汇报工作周期列表(公共)-M3接收出参字段-目标周期父周期ID不能为空", false);
            receptionServiceRes_1 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_1);


            receptionServiceRes_2 = receptionServiceRes_1;
        }

        QueryCustomReportWorkCycleListComRespDto retData = new QueryCustomReportWorkCycleListComRespDto();
        if (receptionServiceRes_2 != null) {
            retData.setTargetContPlanWorkTimeList(receptionServiceRes_2.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1761547_1
            retData.setTargetCycleParentCycleId(receptionServiceRes_2.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1761548_1
            retData.setTargetCycleMidCycleId(receptionServiceRes_2.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:1761549_1
        }


        return retData;
    }

    /**
     * D3分析同一场景下当前子周期(公共)[9461]
     * gen by moon at 9/25/2024, 9:58:29 PM
     */
    @Trace(operationName = "D3分析同一场景下当前子周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisSameSceneCurrentSubCycleComRespDto analysisSameSceneCurrentSubCycleCom(AnalysisSameSceneCurrentSubCycleComReqDto reqDto) {


        //virtualUsage 3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)  67644
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjectTargetCycleByCreateTimeDetailReq queryEvaObjectTargetCycleByCreateTimeDetailReq = new QueryEvaObjectTargetCycleByCreateTimeDetailReq();
        queryEvaObjectTargetCycleByCreateTimeDetailReq.setCycleStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1762595_1_67644
        queryEvaObjectTargetCycleByCreateTimeDetailReq.setCycleEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1762596_1_67644
        queryEvaObjectTargetCycleByCreateTimeDetailReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1763380_1_67644
        queryEvaObjectTargetCycleByCreateTimeDetailReq.setIsArchive("FALSE");//sourceId:1762599_1_67644
        queryEvaObjectTargetCycleByCreateTimeDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1762601_1_67644
        if (reqDto != null) {
            queryEvaObjectTargetCycleByCreateTimeDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1763396_1_67644
            queryEvaObjectTargetCycleByCreateTimeDetailReq.setPlanningType(reqDto.getPlanningType());//SimpleFieldAssign//sourceId:1762597_1_67644
        }

        /*3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)[9462]   */
        Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getCycleStartTime(), "D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-目标计划开始时间不能为空", false);
        Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getCycleEndTime(), "D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-目标计划结束时间不能为空", false);
        Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getTargetCycleContentTypeCode(), "D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-关联目标内容类型编码不能为空", false);
        Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getEvaObjTypeCode(), "D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getPlanningType(), "D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-冗余规划类型不能为空", false);
        Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getIsArchive(), "D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-是否存档不能为空", false);
        Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getSpaceId(), "D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-创建于空间ID不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjectTargetCycleByCreateTimeDetail(queryEvaObjectTargetCycleByCreateTimeDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsEvaluationObjectTargetCycle != null)) {
            //if(3-3-09查最新一条当前子周期ID（同一规划类型）.出参 值不等于空 )  67646

            ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
            if (omsEvaluationObjectTargetCycle != null) {
                ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto = new ImplementStringEfficiencyCheckComReqDto();
                if (omsEvaluationObjectTargetCycle != null) {
                    implementStringEfficiencyCheckComReqDto.setReferenceString(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1762609_1_67653
                }
                if (reqDto != null) {
                    implementStringEfficiencyCheckComReqDto.setComparisonString(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1762610_1_67653
                }

                /*D2-执行字符串对比(公共)[5774]   */
                Assert.isNull(implementStringEfficiencyCheckComReqDto.getReferenceString(), "D3分析同一场景下当前子周期(公共)-D2-执行字符串对比(公共)-参照字符串不能为空", false);
                Assert.isNull(implementStringEfficiencyCheckComReqDto.getComparisonString(), "D3分析同一场景下当前子周期(公共)-D2-执行字符串对比(公共)-对比字符串不能为空", false);
                implementStringEfficiencyCheckComRespDto = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
                Assert.isTrue(implementStringEfficiencyCheckComRespDto == null || implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() == null, "找不到数据，系统异常", false);


            }
            if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))) {
                //if(D2-对比入参子周期ID与当前子周期ID是否相同.字符串对比结果 等于 是)  67655

                List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
                QueryExecuteCycleStageTestListReq queryExecuteCycleStageTestListReq = new QueryExecuteCycleStageTestListReq();
                queryExecuteCycleStageTestListReq.setIsSameSceneCurrentSubCycle("TRUE");//sourceId:1763757_1_67662
                queryExecuteCycleStageTestListReq.setIsArchive("FALSE");//sourceId:1763758_1_67662
                queryExecuteCycleStageTestListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1763759_1_67662

                /*3-3-07查询执行周期阶段列表[4288]   */
                Assert.isNull(queryExecuteCycleStageTestListReq.getIsSameSceneCurrentSubCycle(), "D3分析同一场景下当前子周期(公共)-3-3-07查询执行周期阶段列表-是否规划类型内子周期当前不能为空", false);
                Assert.isNull(queryExecuteCycleStageTestListReq.getIsArchive(), "D3分析同一场景下当前子周期(公共)-3-3-07查询执行周期阶段列表-是否存档不能为空", false);
                Assert.isNull(queryExecuteCycleStageTestListReq.getSpaceId(), "D3分析同一场景下当前子周期(公共)-3-3-07查询执行周期阶段列表-创建于空间ID不能为空", false);
                listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageTestList(queryExecuteCycleStageTestListReq)/*vcase invoke 本地 method 方法调用;*/;


                List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle = new ArrayList<>();
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
                    BatchQueryEvaObjTargetCycleReq batchQueryEvaObjTargetCycleReq = new BatchQueryEvaObjTargetCycleReq();
                    batchQueryEvaObjTargetCycleReq.setIsArchive("FALSE");//sourceId:1763788_1_67664
                    if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                        batchQueryEvaObjTargetCycleReq.setEvaObjTargetCycleList(listOmsExecuteCycleStage.stream().map(item -> item.getEvaObjTargetCycleId())
                                .collect(Collectors.toList()));/*list-to-strings*///sourceId:1763787_1_67664
                    }
                    if (reqDto != null) {
                        batchQueryEvaObjTargetCycleReq.setPlanningType(reqDto.getPlanningType());//SimpleFieldAssign//sourceId:1763791_1_67664
                    }

                    /*3-3-09批量查被评对象目标周期列表[2335]   */
                    Assert.isNull(batchQueryEvaObjTargetCycleReq.getPlanningType(), "D3分析同一场景下当前子周期(公共)-3-3-09批量查被评对象目标周期列表-冗余规划类型不能为空", false);
                    Assert.isNull(batchQueryEvaObjTargetCycleReq.getIsArchive(), "D3分析同一场景下当前子周期(公共)-3-3-09批量查被评对象目标周期列表-是否存档不能为空", false);
                    listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.batchQueryEvaObjTargetCycle(batchQueryEvaObjTargetCycleReq)/*vcase invoke 本地 method 方法调用;*/;


                }
                List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 = new ArrayList<>();
                if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle.size() > 0) {
                    BatchQueryExecuteCycleStageListByTargetCycleIdsReq batchQueryExecuteCycleStageListByTargetCycleIdsReq = new BatchQueryExecuteCycleStageListByTargetCycleIdsReq();
                    batchQueryExecuteCycleStageListByTargetCycleIdsReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1763795_1_67665
                    if (listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle) && listOmsEvaluationObjectTargetCycle != null && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)) {
                        batchQueryExecuteCycleStageListByTargetCycleIdsReq.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle.stream().map(item -> item.getEvaObjTargetCycleId())
                                .collect(Collectors.toList()));/*list-to-strings*///sourceId:1763792_1_67665
                    }

                    /*3-3-07-批量查询执行周期阶段列表By目标周期ID[6508]   */
                    Assert.isNull(batchQueryExecuteCycleStageListByTargetCycleIdsReq.getSubjectLifeCycle(), "D3分析同一场景下当前子周期(公共)-3-3-07-批量查询执行周期阶段列表By目标周期ID-主体生命周期不能为空", false);
                    listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.batchQueryExecuteCycleStageListByTargetCycleIds(batchQueryExecuteCycleStageListByTargetCycleIdsReq)/*vcase invoke 本地 method 方法调用;*/;


                }
                if ((listOmsExecuteCycleStage_2 != null && listOmsExecuteCycleStage_2 != null && listOmsExecuteCycleStage_2.size() > 1)) {
                    //if(3-3-07-查最终执行周期阶段列表（规划下当前子周期执行周期阶段）.执行周期阶段列表数据集条数 大于 1)  67667

//异常结束 67668
                    throw new BizException("undefined", "undefined", false);
                }
                boolean bOOLEAN;
                if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2.size() > 0) {
                    List<OmsExecuteCycleStage> listOmsExecuteCycleStage_4 = new ArrayList<>();
                    if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)) {
                        listOmsExecuteCycleStage_4 = //objList-to-objLists
                                listOmsExecuteCycleStage_2.stream().map(item -> {
                                    OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
                                    elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:355471_2_67666
                                    elm.setIsSameSceneCurrentSubCycle("FALSE");//sourceId:355473_2_67666
                                    return elm;
                                }).collect(Collectors.toList());//objList-to-objLists//sourceId:1763799_1_67666
                    }

                    /*3-3-07批量改执行周期阶段[3150]   */

                    bOOLEAN = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;


                }
                boolean bOOLEAN_1;
                OmsExecuteCycleStage omsExecuteCycleStage = new OmsExecuteCycleStage();
                omsExecuteCycleStage.setIsSameSceneCurrentSubCycle("TRUE");//sourceId:1762995_1_67659
                if (reqDto != null) {
                    omsExecuteCycleStage.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1762994_1_67659
                }

                /*3-3-07修改执行周期阶段[2489]   */
                Assert.isNull(omsExecuteCycleStage.getExecuteCycleStageId(), "D3分析同一场景下当前子周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空", false);
                Assert.isNull(omsExecuteCycleStage.getIsSameSceneCurrentSubCycle(), "D3分析同一场景下当前子周期(公共)-3-3-07修改执行周期阶段-是否规划类型内子周期当前不能为空", false);
                bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
        AnalysisSameSceneCurrentSubCycleComRespDto retData = new AnalysisSameSceneCurrentSubCycleComRespDto();


        return retData;
    }

    /**
     * D3分析第二末级周期场景裁减时间(公共)[9463]
     * gen by moon at 4/30/2024, 11:42:00 AM
     */
    @Trace(operationName = "D3分析第二末级周期场景裁减时间(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisReferenceTimeSecondCycleComRespDto analysisReferenceTimeSecondCycleCom(AnalysisReferenceTimeSecondCycleComReqDto reqDto) {


        ImplementFiveReceivingFieldRespDto receptionServiceRes_1 = null;
//virtualUsage D3查评价模板使用的配置方案ID(公共)  67680
        QueryEvaTempDetailComRespDto queryEvaTempDetailComRespDto = null;
        QueryEvaTempDetailComReqDto queryEvaTempDetailComReqDto = new QueryEvaTempDetailComReqDto();
        queryEvaTempDetailComReqDto.setIsArchive("FALSE");//sourceId:1764580_1_67680
        if (reqDto != null) {
            queryEvaTempDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1764577_1_67680
        }

        /*D3查评价模板使用的配置方案ID(公共)[8468]   */
        Assert.isNull(queryEvaTempDetailComReqDto.getEvaluationTemplateId(), "D3分析第二末级周期场景裁减时间(公共)-D3查评价模板使用的配置方案ID(公共)-评价模板ID不能为空", false);
        Assert.isNull(queryEvaTempDetailComReqDto.getIsArchive(), "D3分析第二末级周期场景裁减时间(公共)-D3查评价模板使用的配置方案ID(公共)-是否存档不能为空", false);
        queryEvaTempDetailComRespDto = evaThemeService.queryEvaTempDetailCom(queryEvaTempDetailComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D2查第二末级周期场景裁减参照周期类型配置答案  67654
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        if (queryEvaTempDetailComRespDto != null) {
            QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
            queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SECOND_LAST_CYCLE_REFERENCE_REDUCE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1763366_1_67654
            queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:1763367_1_67654
            if (queryEvaTempDetailComRespDto != null) {
                queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(queryEvaTempDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:1764575_1_67654
            }

            /*D2查第二末级周期场景裁减参照周期类型配置答案[2486]   */
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfSchemeId(), "D3分析第二末级周期场景裁减时间(公共)-D2查第二末级周期场景裁减参照周期类型配置答案-配置方案ID 不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3分析第二末级周期场景裁减时间(公共)-D2查第二末级周期场景裁减参照周期类型配置答案-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3分析第二末级周期场景裁减时间(公共)-D2查第二末级周期场景裁减参照周期类型配置答案-是否标准答案不能为空", false);
            queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null && !(queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("DISABLE")))) {
            //if((D2查第二末级周期场景裁减参照周期类型配置标准答案（公共）.答案值 值不等于空  and D2查第二末级周期场景裁减参照周期类型配置标准答案（公共）.答案值 不等于 不启用))  67658

            OmsExecuteCycleStage omsExecuteCycleStage = null;
            if (queryConfItemMatchAnswerDetailComRespDto != null) {
                QueryExecuteCycleEqualStartrAndGreateDetailReq queryExecuteCycleEqualStartrAndGreateDetailReq = new QueryExecuteCycleEqualStartrAndGreateDetailReq();
                queryExecuteCycleEqualStartrAndGreateDetailReq.setCycleStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1763382_1_67661
                queryExecuteCycleEqualStartrAndGreateDetailReq.setCycleEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1763383_1_67661
                queryExecuteCycleEqualStartrAndGreateDetailReq.setIsArchive("FALSE");//sourceId:1763386_1_67661
                if (queryConfItemMatchAnswerDetailComRespDto != null) {
                    queryExecuteCycleEqualStartrAndGreateDetailReq.setCycleTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1763390_1_67661
                }
                if (reqDto != null) {
                    queryExecuteCycleEqualStartrAndGreateDetailReq.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1763384_1_67661
                    queryExecuteCycleEqualStartrAndGreateDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1763385_1_67661
                    queryExecuteCycleEqualStartrAndGreateDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1763387_1_67661
                }

                /*3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）[9464]   */
                Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getCycleStartTime(), "D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-周期开始时间不能为空", false);
                Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getCycleEndTime(), "D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-周期结束时间不能为空", false);
                Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getCycleTypeCode(), "D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-周期类型标识不能为空", false);
                Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getRelateContentTypeCode(), "D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-关联目标内容类型编码不能为空", false);
                Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getEvaluationTemplateId(), "D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-评价模板ID不能为空", false);
                Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getIsArchive(), "D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-是否存档不能为空", false);
                Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getSpaceId(), "D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-创建于空间ID不能为空", false);
                omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleEqualStartrAndGreateDetail(queryExecuteCycleEqualStartrAndGreateDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: receptionService
            ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
            if (omsExecuteCycleStage != null) {
                ImplementFiveReceivingFieldReqDto receptionServiceReq = new ImplementFiveReceivingFieldReqDto();
                if (omsExecuteCycleStage != null) {
                    receptionServiceReq.setComTimeField(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:1763763_1_67663
                }

                /*M3接收参照时间出参[8467]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getComTimeField(), "D3分析第二末级周期场景裁减时间(公共)-M3接收参照时间出参-通用时间字段不能为空", false);
                receptionServiceRes = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        }
        AnalysisReferenceTimeSecondCycleComRespDto retData = new AnalysisReferenceTimeSecondCycleComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setComTimeField(receptionServiceRes_1.getComTimeField());//SimpleFieldAssign//sourceId:1763765_1
        }


        return retData;
    }

    /**
     * D3更新子周期为规划下当前(公共)[9465]
     * gen by moon at 5/3/2024, 8:05:59 PM
     */
    @Trace(operationName = "D3更新子周期为规划下当前(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public TimingRefreshSubCycleIsPlanCurrentComRespDto timingRefreshSubCycleIsPlanCurrentCom(TimingRefreshSubCycleIsPlanCurrentComReqDto reqDto) {


        //步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
        //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
        ImplementEightReceivingFieldReqDto receptionServiceReq = new ImplementEightReceivingFieldReqDto();
        if (reqDto != null && reqDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())) {
            receptionServiceReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1764234_1
        }
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1764244_1
        }

        /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3更新子周期为规划下当前(公共)-M3接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbCustomExecutionCycle.implementEightReceivingField(receptionServiceReq);


//步骤1: M3-执行执行周期阶段【循环开始】 - implementExecCycleStageLoopStart
        //ModelCode: circulationCollections
        for (ExecuteCycleStageDto circulationCollectionsRes : reqDto.getExecuteCycleStageList()) {


//步骤2: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1764241_1
            if (circulationCollectionsRes != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1764239_1
            }
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1764240_1
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3更新子周期为规划下当前(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3更新子周期为规划下当前(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(), "D3更新子周期为规划下当前(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤3: D3分析同一场景下当前子周期(公共) - analysisSameSceneCurrentSubCycleCom
            AnalysisSameSceneCurrentSubCycleComRespDto analysisSameSceneCurrentSubCycleComRespDto = null;
            if (omsEvaluationObjectTargetCycle != null) {
                AnalysisSameSceneCurrentSubCycleComReqDto analysisSameSceneCurrentSubCycleComReqDto = new AnalysisSameSceneCurrentSubCycleComReqDto();
                if (circulationCollectionsRes != null) {
                    analysisSameSceneCurrentSubCycleComReqDto.setExecuteCycleStageId(circulationCollectionsRes.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1763810_1
                    analysisSameSceneCurrentSubCycleComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1763808_1
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    analysisSameSceneCurrentSubCycleComReqDto.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1763811_1
                    analysisSameSceneCurrentSubCycleComReqDto.setPlanningType(omsEvaluationObjectTargetCycle.getPlanningType());//SimpleFieldAssign//sourceId:1763809_1
                }

                /*D3分析同一场景下当前子周期(公共)[9461]   */
                Assert.isNull(analysisSameSceneCurrentSubCycleComReqDto.getExecuteCycleStageId(), "D3更新子周期为规划下当前(公共)-D3分析同一场景下当前子周期(公共)-执行周期阶段ID不能为空", false);
                Assert.isNull(analysisSameSceneCurrentSubCycleComReqDto.getEvaObjTargetCycleId(), "D3更新子周期为规划下当前(公共)-D3分析同一场景下当前子周期(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(analysisSameSceneCurrentSubCycleComReqDto.getEvaObjTypeCode(), "D3更新子周期为规划下当前(公共)-D3分析同一场景下当前子周期(公共)-被评对象类型编码不能为空", false);
                Assert.isNull(analysisSameSceneCurrentSubCycleComReqDto.getPlanningType(), "D3更新子周期为规划下当前(公共)-D3分析同一场景下当前子周期(公共)-冗余规划类型不能为空", false);
                analysisSameSceneCurrentSubCycleComRespDto = analysisSameSceneCurrentSubCycleCom(analysisSameSceneCurrentSubCycleComReqDto)/*vcase invoke 同服务,同domain*/;


            }

//步骤4: M3-执行【循环结束】 - implementLoopEnd
            //ModelCode: circulationEnd
        }


        TimingRefreshSubCycleIsPlanCurrentComRespDto retData = new TimingRefreshSubCycleIsPlanCurrentComRespDto();


        return retData;
    }

    /**
     * D3执行子周期最大双周推内存(公共)[9771]
     * gen by moon at 6/9/2024, 4:35:18 PM
     */
    @Trace(operationName = "D3执行子周期最大双周推内存(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementSubCycleBigDubbleWeeksMemoryComRespDto implementSubCycleBigDubbleWeeksMemoryCom(ImplementSubCycleBigDubbleWeeksMemoryComReqDto reqDto) {


        //virtualUsage D2执行数据集取一条（含时间）(公共)  69823
        ImplementDatasFetchLastLatestWithTimeComRespDto implementDatasFetchLastLatestWithTimeComRespDto = null;
        ImplementDatasFetchLastLatestWithTimeComReqDto implementDatasFetchLastLatestWithTimeComReqDto = new ImplementDatasFetchLastLatestWithTimeComReqDto();
        implementDatasFetchLastLatestWithTimeComReqDto.setOrderSizeType("FROM_LARGE_SMALL");//sourceId:1860670_1_69823
        if (reqDto != null && reqDto.getCycleList() != null && !CollectionUtil.isEmpty(reqDto.getCycleList())) {
            implementDatasFetchLastLatestWithTimeComReqDto.setComDatasList(//objList-to-objLists
                    reqDto.getCycleList().stream().map(item -> {
                        ComDatasDto elm = new ComDatasDto();
                        if (item != null) {
                            elm.setCustomField1(item.getCycleStandardName());//SimpleFieldAssign//sourceId:372460_2_69823
                            elm.setComTimeField1(item.getCycleStartTime());//SimpleFieldAssign//sourceId:372703_2_69823
                            elm.setComTimeField2(item.getCycleEndTime());//SimpleFieldAssign//sourceId:372704_2_69823
                        }
                        return elm;
                    }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1858610_1_69823
        }

        /*D2执行数据集取一条（含时间）(公共)[9774]   */
        Assert.isNull(implementDatasFetchLastLatestWithTimeComReqDto.getOrderSizeType(), "D3执行子周期最大双周推内存(公共)-D2执行数据集取一条（含时间）(公共)-排序大小类型不能为空", false);
        implementDatasFetchLastLatestWithTimeComRespDto = interfaceModeService.implementDatasFetchLastLatestWithTimeCom(implementDatasFetchLastLatestWithTimeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D2执行时间格式转换(公共)  69821
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
        if (implementDatasFetchLastLatestWithTimeComRespDto != null) {
            ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto = new ImplementTimeFormatConversionComReqDto();
            if (implementDatasFetchLastLatestWithTimeComRespDto != null) {
                implementTimeFormatConversionComReqDto.setComTxtField(implementDatasFetchLastLatestWithTimeComRespDto.getComTimeField1() != null ? String.valueOf(implementDatasFetchLastLatestWithTimeComRespDto.getComTimeField1()) : "");//SimpleFieldAssign//sourceId:1858045_1_69821
            }

            /*D2执行时间格式转换(公共)[9757]   */
            Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(), "D3执行子周期最大双周推内存(公共)-D2执行时间格式转换(公共)-通用文本字段不能为空", false);
            implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage D2执行时间格式转换(公共)  69820
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
        if (implementDatasFetchLastLatestWithTimeComRespDto != null) {
            ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1 = new ImplementTimeFormatConversionComReqDto();
            if (implementDatasFetchLastLatestWithTimeComRespDto != null) {
                implementTimeFormatConversionComReqDto_1.setComTxtField(implementDatasFetchLastLatestWithTimeComRespDto.getComTimeField2() != null ? String.valueOf(implementDatasFetchLastLatestWithTimeComRespDto.getComTimeField2()) : "");//SimpleFieldAssign//sourceId:1858045_1_69820
            }

            /*D2执行时间格式转换(公共)[9757]   */
            Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(), "D3执行子周期最大双周推内存(公共)-D2执行时间格式转换(公共)-通用文本字段不能为空", false);
            implementTimeFormatConversionComRespDto_2 = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage D3新增内存业务数据(业务原子)  69822
        AddMemoryBusinessSetDataComRespDto addMemoryBusinessSetDataComRespDto = null;
        if (implementDatasFetchLastLatestWithTimeComRespDto != null && implementTimeFormatConversionComRespDto != null && implementTimeFormatConversionComRespDto_2 != null) {
            AddMemoryBusinessSetDataComReqDto addMemoryBusinessSetDataComReqDto = new AddMemoryBusinessSetDataComReqDto();
            addMemoryBusinessSetDataComReqDto.setIsDataList("FALSE");//sourceId:1858042_1_69822
            addMemoryBusinessSetDataComReqDto.setCustomField1("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:1858043_1_69822
            addMemoryBusinessSetDataComReqDto.setCustomField2("cycleStandardName");//CUSTOM_CONVENTION//sourceId:1858244_1_69822
            addMemoryBusinessSetDataComReqDto.setCustomField3("cycleStartTime");//CUSTOM_CONVENTION//sourceId:1858252_1_69822
            addMemoryBusinessSetDataComReqDto.setCustomField4("cycleEndTime");//CUSTOM_CONVENTION//sourceId:1858624_1_69822
            if (reqDto != null) {
                addMemoryBusinessSetDataComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1858041_1_69822
                addMemoryBusinessSetDataComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1858040_1_69822
                addMemoryBusinessSetDataComReqDto.setCustomFieldValue1(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1858044_1_69822
            }
            if (implementDatasFetchLastLatestWithTimeComRespDto != null) {
                addMemoryBusinessSetDataComReqDto.setCustomFieldValue2(implementDatasFetchLastLatestWithTimeComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1858245_1_69822
            }
            if (implementTimeFormatConversionComRespDto != null) {
                addMemoryBusinessSetDataComReqDto.setCustomFieldValue3(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1858253_1_69822
            }
            if (implementTimeFormatConversionComRespDto_2 != null) {
                addMemoryBusinessSetDataComReqDto.setCustomFieldValue4(implementTimeFormatConversionComRespDto_2.getComTxtField());//SimpleFieldAssign//sourceId:1858625_1_69822
            }

            /*D3新增内存业务数据(业务原子)[8643]   */
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getBusinessDataObject(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-业务数据对象不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getDataObjectBatchCode(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-数据对象批次标识不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getIsDataList(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-是否是数据集对象不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomField1(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段1不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomFieldValue1(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段值1不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomField2(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段2不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomFieldValue2(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段值2不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomField3(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段3不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomFieldValue3(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段值3不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomField4(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段4不能为空", false);
            Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomFieldValue4(), "D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段值4不能为空", false);
            addMemoryBusinessSetDataComRespDto = businessAtomService.addMemoryBusinessSetDataCom(addMemoryBusinessSetDataComReqDto)/*vcase invoke isSameApp*/;


        }
        ImplementSubCycleBigDubbleWeeksMemoryComRespDto retData = new ImplementSubCycleBigDubbleWeeksMemoryComRespDto();


        return retData;
    }

    /**
     * D3分析子周期双周周期开始时间(公共)[9772]
     * gen by moon at 6/9/2024, 4:35:41 PM
     */
    @Trace(operationName = "D3分析子周期双周周期开始时间(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisSubCycleBiweeklyStartTimeComRespDto analysisSubCycleBiweeklyStartTimeCom(AnalysisSubCycleBiweeklyStartTimeComReqDto reqDto) {


        ImplementElevenReceivingFieldRespDto receptionServiceRes_1 = null;
//virtualUsage D2两个时间对比（公共）  69832
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
        CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
        if (reqDto != null) {
            checkTimeScopeSearchComReqDto.setCurrentTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1859411_1_69832
            checkTimeScopeSearchComReqDto.setCompareTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859413_1_69832
        }

        /*D2两个时间对比（公共）[3297]   */
        Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3分析子周期双周周期开始时间(公共)-D2两个时间对比（公共）-当前时间不能为空", false);
        Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3分析子周期双周周期开始时间(公共)-D2两个时间对比（公共）-比较时间不能为空", false);
        checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))) {
            //if(D2父周期开始时间与子周期开始时间对比（用于判断是否相同）.时间比较结果 等于 当前（等于）)  69833

            OmsCycle omsCycle = null;
            QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq = new QueryTimeRangeFindCycleDetailReq();
            queryTimeRangeFindCycleDetailReq.setCycleTypeCode("WEEK");//CUSTOM_CONVENTION//sourceId:1859418_1_69839
            queryTimeRangeFindCycleDetailReq.setPlatformData("TRUE");//sourceId:1859419_1_69839
            queryTimeRangeFindCycleDetailReq.setIsArchive("FALSE");//sourceId:1860698_1_69839
            if (reqDto != null) {
                queryTimeRangeFindCycleDetailReq.setCycleStartTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859416_1_69839
                queryTimeRangeFindCycleDetailReq.setCycleEndTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859417_1_69839
            }

            /*3-4-04查子周期开始第一周周期[7005]   */
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期开始时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期结束时间不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期类型标识不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-是否是平台不能为空", false);
            Assert.isNull(queryTimeRangeFindCycleDetailReq.getIsArchive(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-是否存档不能为空", false);
            omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
            ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
            if (omsCycle != null) {
                ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
                if (omsCycle != null) {
                    receptionServiceReq.setCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:1859633_1_69841
                    receptionServiceReq.setCycleStartTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1859635_1_69841
                    receptionServiceReq.setCycleEndTime(omsCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:1859634_1_69841
                }

                /*M3接收周期开始时间出参[9482]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getCycleStartTime(), "D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期开始时间不能为空", false);
                Assert.isNull(receptionServiceReq.getCycleEndTime(), "D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期结束时间不能为空", false);
                receptionServiceRes = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("BEFORE") || checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))) {
            //elseif((D2父周期开始时间与子周期开始时间对比（用于判断是否相同）.时间比较结果 等于 之前（小于） or D2父周期开始时间与子周期开始时间对比（用于判断是否相同）.时间比较结果 等于 之后（大于）))  69834

            QueryMemoryBusinessDataSetDetailComRespDto queryMemoryBusinessDataSetDetailComRespDto = null;
            QueryMemoryBusinessDataSetDetailComReqDto queryMemoryBusinessDataSetDetailComReqDto = new QueryMemoryBusinessDataSetDetailComReqDto();
            queryMemoryBusinessDataSetDetailComReqDto.setCustomField1("cycleStartTime");//CUSTOM_CONVENTION//sourceId:1858573_1_69835
            queryMemoryBusinessDataSetDetailComReqDto.setCustomField2("cycleEndTime");//CUSTOM_CONVENTION//sourceId:1858574_1_69835
            if (reqDto != null) {
                queryMemoryBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1858572_1_69835
                queryMemoryBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1858571_1_69835
            }

            /*D3查询当前最新的子周期最后一个双周开始与结束时间（内存）[8644]   */
            Assert.isNull(queryMemoryBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D3分析子周期双周周期开始时间(公共)-D3查询当前最新的子周期最后一个双周开始与结束时间（内存）-业务数据对象不能为空", false);
            Assert.isNull(queryMemoryBusinessDataSetDetailComReqDto.getDataObjectBatchCode(), "D3分析子周期双周周期开始时间(公共)-D3查询当前最新的子周期最后一个双周开始与结束时间（内存）-数据对象批次标识不能为空", false);
            Assert.isNull(queryMemoryBusinessDataSetDetailComReqDto.getCustomField1(), "D3分析子周期双周周期开始时间(公共)-D3查询当前最新的子周期最后一个双周开始与结束时间（内存）-自定义字段1不能为空", false);
            Assert.isNull(queryMemoryBusinessDataSetDetailComReqDto.getCustomField2(), "D3分析子周期双周周期开始时间(公共)-D3查询当前最新的子周期最后一个双周开始与结束时间（内存）-自定义字段2不能为空", false);
            queryMemoryBusinessDataSetDetailComRespDto = businessAtomService.queryMemoryBusinessDataSetDetailCom(queryMemoryBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


            CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
            if (queryMemoryBusinessDataSetDetailComRespDto != null) {
                CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1 = new CheckTimeScopeSearchComReqDto();
                if (queryMemoryBusinessDataSetDetailComRespDto != null) {
                    checkTimeScopeSearchComReqDto_1.setCurrentTime(queryMemoryBusinessDataSetDetailComRespDto.getCustomField2() != null ? CommonFunctionHelper.str2Date(queryMemoryBusinessDataSetDetailComRespDto.getCustomField2()) : null);//SimpleFieldAssign//sourceId:1859411_1_69836
                }
                if (reqDto != null) {
                    checkTimeScopeSearchComReqDto_1.setCompareTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859413_1_69836
                }

                /*D2两个时间对比（公共）[3297]   */
                Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(), "D3分析子周期双周周期开始时间(公共)-D2两个时间对比（公共）-当前时间不能为空", false);
                Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(), "D3分析子周期双周周期开始时间(公共)-D2两个时间对比（公共）-比较时间不能为空", false);
                checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("BEFORE"))) {
                //if(D2内存中周期结束时间与子周期开始时间对比（公共）.时间比较结果 等于 之前（小于）)  69837

                OmsCycle omsCycle_2 = null;
                QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq_1 = new QueryTimeRangeFindCycleDetailReq();
                queryTimeRangeFindCycleDetailReq_1.setCycleTypeCode("WEEK");//CUSTOM_CONVENTION//sourceId:1859418_1_69840
                queryTimeRangeFindCycleDetailReq_1.setPlatformData("TRUE");//sourceId:1859419_1_69840
                queryTimeRangeFindCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1860698_1_69840
                if (reqDto != null) {
                    queryTimeRangeFindCycleDetailReq_1.setCycleStartTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859416_1_69840
                    queryTimeRangeFindCycleDetailReq_1.setCycleEndTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859417_1_69840
                }

                /*3-4-04查子周期开始第一周周期[7005]   */
                Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleStartTime(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期开始时间不能为空", false);
                Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleEndTime(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期结束时间不能为空", false);
                Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleTypeCode(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期类型标识不能为空", false);
                Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getPlatformData(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-是否是平台不能为空", false);
                Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getIsArchive(), "D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-是否存档不能为空", false);
                omsCycle_2 = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
                if (omsCycle_2 != null) {
                    ImplementElevenReceivingFieldReqDto receptionServiceReq_1 = new ImplementElevenReceivingFieldReqDto();
                    if (omsCycle_2 != null) {
                        receptionServiceReq_1.setCycleId(omsCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1859633_1_69842
                        receptionServiceReq_1.setCycleStartTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1859635_1_69842
                        receptionServiceReq_1.setCycleEndTime(omsCycle_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1859634_1_69842
                    }

                    /*M3接收周期开始时间出参[9482]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_1.getCycleStartTime(), "D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期开始时间不能为空", false);
                    Assert.isNull(receptionServiceReq_1.getCycleEndTime(), "D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期结束时间不能为空", false);
                    receptionServiceRes_2 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_1);


                    receptionServiceRes_1 = receptionServiceRes_2;
                }
            } else if ((checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT") || checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("LATER"))) {
                //elseif((D2内存中周期结束时间与子周期开始时间对比（公共）.时间比较结果 等于 当前（等于） or D2内存中周期结束时间与子周期开始时间对比（公共）.时间比较结果 等于 之后（大于）))  69838

//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
                if (queryMemoryBusinessDataSetDetailComRespDto != null) {
                    ImplementElevenReceivingFieldReqDto receptionServiceReq_2 = new ImplementElevenReceivingFieldReqDto();
                    if (queryMemoryBusinessDataSetDetailComRespDto != null) {
                        receptionServiceReq_2.setCycleStartTime(queryMemoryBusinessDataSetDetailComRespDto.getCustomField1() != null ? CommonFunctionHelper.str2Date(queryMemoryBusinessDataSetDetailComRespDto.getCustomField1()) : null);//SimpleFieldAssign//sourceId:1859635_1_69843
                        receptionServiceReq_2.setCycleEndTime(queryMemoryBusinessDataSetDetailComRespDto.getCustomField2() != null ? CommonFunctionHelper.str2Date(queryMemoryBusinessDataSetDetailComRespDto.getCustomField2()) : null);//SimpleFieldAssign//sourceId:1859634_1_69843
                    }

                    /*M3接收周期开始时间出参[9482]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_2.getCycleStartTime(), "D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期开始时间不能为空", false);
                    Assert.isNull(receptionServiceReq_2.getCycleEndTime(), "D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期结束时间不能为空", false);
                    receptionServiceRes_3 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_2);


                    receptionServiceRes_1 = receptionServiceRes_3;
                }
            }
        }
        AnalysisSubCycleBiweeklyStartTimeComRespDto retData = new AnalysisSubCycleBiweeklyStartTimeComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setCycleId(receptionServiceRes_1.getCycleId());//SimpleFieldAssign//sourceId:1859700_1
            retData.setCycleStartTime(receptionServiceRes_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1859701_1
            retData.setCycleEndTime(receptionServiceRes_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1859702_1
        }


        return retData;
    }

    /**
     * D3分析目标内容自定义过程执行周期范围(公共)[9835]
     * gen by moon at 7/10/2024, 6:45:10 PM
     */
    @Trace(operationName = "D3分析目标内容自定义过程执行周期范围(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisTargetContentCustomProcessExecutionCycleRangeComRespDto analysisTargetContentCustomProcessExecutionCycleRangeCom(AnalysisTargetContentCustomProcessExecutionCycleRangeComReqDto reqDto) {


        ImplementElevenReceivingFieldRespDto receptionServiceRes_1 = null;
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage_5 = new ArrayList<>();
        List<OmsExecuteCycleStage> listOmsExecuteCycleStage_7 = new ArrayList<>();
//virtualUsage 3-3-09查被评对象目标周期详情  70396
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1879574_1_70396
        queryEvaObjTargetCycleDetailReq.setIsSubCycle("TRUE");//sourceId:1879577_1_70396
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1879579_1_70396
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1879575_1_70396
            queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1879576_1_70396
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879578_1_70396
        }

        /*3-3-09查被评对象目标周期详情[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsSubCycle(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-是否子周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-3-08查询目标周期规划设置详情  70397
        OmsTargetCyclePlanSet omsTargetCyclePlanSet = null;
        if (omsEvaluationObjectTargetCycle != null) {
            QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq = new QueryTargetCyclePsetDetailReq();
            queryTargetCyclePsetDetailReq.setIsArchive("FALSE");//sourceId:1879568_1_70397
            if (omsEvaluationObjectTargetCycle != null) {
                queryTargetCyclePsetDetailReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1879561_1_70397
            }
            if (reqDto != null) {
                queryTargetCyclePsetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879566_1_70397
            }

            /*3-3-08查询目标周期规划设置详情[3368]   */
            Assert.isNull(queryTargetCyclePsetDetailReq.getEvaObjTargetCycleId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-08查询目标周期规划设置详情-归属被评对象目标周期ID不能为空", false);
            Assert.isNull(queryTargetCyclePsetDetailReq.getEvaluationTemplateId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-08查询目标周期规划设置详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetCyclePsetDetailReq.getIsArchive(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-08查询目标周期规划设置详情-是否存档不能为空", false);
            omsTargetCyclePlanSet = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        }
//virtualUsage D2两个时间对比大小(公共)  70398
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
        if (omsTargetCyclePlanSet != null) {
            CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
            if (reqDto != null) {
                checkTimeScopeSearchComReqDto.setCurrentTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1879475_1_70398
            }
            if (omsTargetCyclePlanSet != null) {
                checkTimeScopeSearchComReqDto.setCompareTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1879477_1_70398
            }

            /*D2两个时间对比大小(公共)[3297]   */
            Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3分析目标内容自定义过程执行周期范围(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
            Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3分析目标内容自定义过程执行周期范围(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
            checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage D2两个时间对比大小(公共)  70399
        CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
        if (omsTargetCyclePlanSet != null) {
            CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1 = new CheckTimeScopeSearchComReqDto();
            if (reqDto != null) {
                checkTimeScopeSearchComReqDto_1.setCurrentTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1879475_1_70399
            }
            if (omsTargetCyclePlanSet != null) {
                checkTimeScopeSearchComReqDto_1.setCompareTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1879477_1_70399
            }

            /*D2两个时间对比大小(公共)[3297]   */
            Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(), "D3分析目标内容自定义过程执行周期范围(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
            Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(), "D3分析目标内容自定义过程执行周期范围(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
            checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage 3-3-07查询执行周期阶段详情  70405
        OmsExecuteCycleStage omsExecuteCycleStage = null;
        QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
        queryExecuteCycleStageDetailReq.setIsSubCycle("TRUE");//sourceId:1879900_1_70405
        queryExecuteCycleStageDetailReq.setIsProcessCycleStage("FALSE");//sourceId:1879903_1_70405
        queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1879902_1_70405
        if (reqDto != null) {
            queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1879898_1_70405
            queryExecuteCycleStageDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1879899_1_70405
            queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879901_1_70405
        }

        /*3-3-07查询执行周期阶段详情[2429]   */
        Assert.isNull(queryExecuteCycleStageDetailReq.getEvaObjTargetCycleId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getIsSubCycle(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-是否子周期不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
        omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT") && checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT"))) {
            //if((D2目标内容的成果汇报开始时间与目标的成果汇报开始时间对比.时间比较结果 等于 当前（等于） and D2目标内容的成果汇报结束时间与目标的成果汇报结束时间对比.时间比较结果 等于 当前（等于）))  70400

            List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
            if (omsEvaluationObjectTargetCycle != null) {
                QueryListByTimeSliceExecuteCycleStageReq queryListByTimeSliceExecuteCycleStageReq = new QueryListByTimeSliceExecuteCycleStageReq();
                queryListByTimeSliceExecuteCycleStageReq.setIsProcessCycleStage("TRUE");//sourceId:1879905_1_70403
                queryListByTimeSliceExecuteCycleStageReq.setIsArchive("FALSE");//sourceId:1879907_1_70403
                if (omsEvaluationObjectTargetCycle != null) {
                    queryListByTimeSliceExecuteCycleStageReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1879904_1_70403
                }
                if (reqDto != null) {
                    queryListByTimeSliceExecuteCycleStageReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879906_1_70403
                }

                /*3-3-07查询目标周期下的所有执行周期阶段列表[5982]   */
                Assert.isNull(queryListByTimeSliceExecuteCycleStageReq.getEvaObjTargetCycleId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询目标周期下的所有执行周期阶段列表-被评对象目标周期ID不能为空", false);
                Assert.isNull(queryListByTimeSliceExecuteCycleStageReq.getIsProcessCycleStage(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询目标周期下的所有执行周期阶段列表-是否过程周期阶段不能为空", false);
                Assert.isNull(queryListByTimeSliceExecuteCycleStageReq.getEvaluationTemplateId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询目标周期下的所有执行周期阶段列表-评价模板ID不能为空", false);
                Assert.isNull(queryListByTimeSliceExecuteCycleStageReq.getIsArchive(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询目标周期下的所有执行周期阶段列表-是否存档不能为空", false);
                listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryListByTimeSliceExecuteCycleStage(queryListByTimeSliceExecuteCycleStageReq)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: receptionService
            ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
            if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0 && omsExecuteCycleStage != null) {
                ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                    OmsExecuteCycleStage finalOmsExecuteCycleStage = omsExecuteCycleStage;
                    receptionServiceReq.setExecuteCycleStageList(//objList-to-objLists
                            listOmsExecuteCycleStage.stream().map(item -> {
                                ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
                                elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:376191_2_70404
                                elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:376193_2_70404
                                elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:376194_2_70404
                                elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:376195_2_70404
                                elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:376196_2_70404
                                elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:376197_2_70404
                                elm.setCycleTypeInstanceCode(item.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:376198_2_70404
                                elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:376199_2_70404
                                elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:376200_2_70404
                                elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:376201_2_70404
                                elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:376202_2_70404
                                elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:376203_2_70404
                                elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:376204_2_70404
                                elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:376205_2_70404
                                elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:376206_2_70404
                                elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:376207_2_70404
                                elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:376208_2_70404
                                elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:376209_2_70404
                                elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:376210_2_70404
                                elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:376212_2_70404
                                elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:376213_2_70404
                                elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:376214_2_70404
                                elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:376219_2_70404
                                elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:376220_2_70404
                                if (reqDto != null) {
                                    elm.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376211_2_70404
                                    elm.setTargetId(reqDto.getTargetId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376217_2_70404
                                    elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376218_2_70404
                                }
                                if (finalOmsExecuteCycleStage != null) {
                                    elm.setRelateContentTypeCode(finalOmsExecuteCycleStage.getRelateContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376215_2_70404
                                    elm.setRelateContentId(finalOmsExecuteCycleStage.getRelateContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376216_2_70404
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1879897_1_70404
                }

                /*M3-接收出参数据集：执行周期阶段列表[9482]  用于特殊方法接收上游入参。 */

                receptionServiceRes = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((!(checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")) || !(checkTimeScopeSearchComRespDto_2 != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))) {
            //elseif((D2目标内容的成果汇报开始时间与目标的成果汇报开始时间对比.时间比较结果 不等于 当前（等于） or D2目标内容的成果汇报结束时间与目标的成果汇报结束时间对比.时间比较结果 不等于 当前（等于）))  70401

            List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 = new ArrayList<>();
            if (omsEvaluationObjectTargetCycle != null) {
                QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq = new QuerySubCycleExecuteCycleStageListReq();
                querySubCycleExecuteCycleStageListReq.setIsProcessCycleStage("TRUE");//sourceId:1879990_1_70407
                querySubCycleExecuteCycleStageListReq.setIsArchive("FALSE");//sourceId:1879992_1_70407
                if (omsEvaluationObjectTargetCycle != null) {
                    querySubCycleExecuteCycleStageListReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1879987_1_70407
                }
                if (reqDto != null) {
                    querySubCycleExecuteCycleStageListReq.setCycleStartTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1879988_1_70407
                    querySubCycleExecuteCycleStageListReq.setCycleEndTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1879989_1_70407
                    querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879991_1_70407
                }

                /*3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）[4718]   */
                Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaObjTargetCycleId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-被评对象目标周期ID不能为空", false);
                Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleStartTime(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空", false);
                Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空", false);
                Assert.isNull(querySubCycleExecuteCycleStageListReq.getIsProcessCycleStage(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-是否过程周期阶段不能为空", false);
                Assert.isNull(querySubCycleExecuteCycleStageListReq.getIsArchive(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-是否存档不能为空", false);
                Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空", false);
                listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


            }
            List<OmsExecuteCycleStage> listOmsExecuteCycleStage_4 = new ArrayList<>();
            if (omsEvaluationObjectTargetCycle != null) {
                QueryExecuteCycleLessStartAndGreaterEqualStartListReq queryExecuteCycleLessStartAndGreaterEqualStartListReq = new QueryExecuteCycleLessStartAndGreaterEqualStartListReq();
                queryExecuteCycleLessStartAndGreaterEqualStartListReq.setIsProcessCycleStage("TRUE");//sourceId:1880790_1_70450
                queryExecuteCycleLessStartAndGreaterEqualStartListReq.setIsArchive("FALSE");//sourceId:1880793_1_70450
                if (omsEvaluationObjectTargetCycle != null) {
                    queryExecuteCycleLessStartAndGreaterEqualStartListReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1880791_1_70450
                }
                if (reqDto != null) {
                    queryExecuteCycleLessStartAndGreaterEqualStartListReq.setCycleStartTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1880788_1_70450
                    queryExecuteCycleLessStartAndGreaterEqualStartListReq.setCycleEndTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1880789_1_70450
                    queryExecuteCycleLessStartAndGreaterEqualStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1880792_1_70450
                }

                /*3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）[9838]   */
                Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getEvaObjTargetCycleId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-被评对象目标周期ID不能为空", false);
                Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getCycleStartTime(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-周期开始时间不能为空", false);
                Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getCycleEndTime(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-周期结束时间不能为空", false);
                Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getIsProcessCycleStage(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-是否过程周期阶段不能为空", false);
                Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getIsArchive(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-是否存档不能为空", false);
                Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getEvaluationTemplateId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-评价模板ID不能为空", false);
                listOmsExecuteCycleStage_4 = mOmsExecuteCycleStageService.queryExecuteCycleLessStartAndGreaterEqualStartList(queryExecuteCycleLessStartAndGreaterEqualStartListReq)/*vcase invoke 本地 method 方法调用;*/;


                listOmsExecuteCycleStage_5 = listOmsExecuteCycleStage_4;
            }
            List<OmsExecuteCycleStage> listOmsExecuteCycleStage_6 = new ArrayList<>();
            if (omsEvaluationObjectTargetCycle != null) {
                QueryExecuteCycleStageListReq queryExecuteCycleStageListReq = new QueryExecuteCycleStageListReq();
                queryExecuteCycleStageListReq.setIsProcessCycleStage("TRUE");//sourceId:1880541_1_70449
                queryExecuteCycleStageListReq.setIsArchive("FALSE");//sourceId:1880543_1_70449
                if (omsEvaluationObjectTargetCycle != null) {
                    queryExecuteCycleStageListReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1880538_1_70449
                }
                if (reqDto != null) {
                    queryExecuteCycleStageListReq.setCycleStartTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1880539_1_70449
                    queryExecuteCycleStageListReq.setCycleEndTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1880540_1_70449
                    queryExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1880542_1_70449
                }

                /*3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）[3201]   */
                Assert.isNull(queryExecuteCycleStageListReq.getEvaObjTargetCycleId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-被评对象目标周期ID不能为空", false);
                Assert.isNull(queryExecuteCycleStageListReq.getCycleStartTime(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-周期开始时间不能为空", false);
                Assert.isNull(queryExecuteCycleStageListReq.getCycleEndTime(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-周期结束时间不能为空", false);
                Assert.isNull(queryExecuteCycleStageListReq.getIsProcessCycleStage(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-是否过程周期阶段不能为空", false);
                Assert.isNull(queryExecuteCycleStageListReq.getIsArchive(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-是否存档不能为空", false);
                Assert.isNull(queryExecuteCycleStageListReq.getEvaluationTemplateId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-评价模板ID不能为空", false);
                listOmsExecuteCycleStage_6 = mOmsExecuteCycleStageService.queryExecuteCycleStageList(queryExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


                listOmsExecuteCycleStage_7 = listOmsExecuteCycleStage_6;
            }
            // TODO: 2024/6/22  勿合
            ImplementMergeTargetContentCustomProcessExecutionCycleComRespDto implementMergeTargetContentCustomProcessExecutionCycleComRespDto = null;
            if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2.size() > 0 || listOmsExecuteCycleStage_4 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4) && listOmsExecuteCycleStage_4.size() > 0 || listOmsExecuteCycleStage_6 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6) && listOmsExecuteCycleStage_6.size() > 0) {
                ImplementMergeTargetContentCustomProcessExecutionCycleComReqDto implementMergeTargetContentCustomProcessExecutionCycleComReqDto = new ImplementMergeTargetContentCustomProcessExecutionCycleComReqDto();
                if (listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2) && listOmsExecuteCycleStage_2 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)) {
                    implementMergeTargetContentCustomProcessExecutionCycleComReqDto.setWithinSubCycleExecuteCycleStageList(listOmsExecuteCycleStage_2.stream().map(item -> item.getExecuteCycleStageId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:1880484_1_70441
                }
                if (listOmsExecuteCycleStage_4 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4) && listOmsExecuteCycleStage_4 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4)) {
                    implementMergeTargetContentCustomProcessExecutionCycleComReqDto.setSubCycleStartTimeExecuteCycleStageList(listOmsExecuteCycleStage_4.stream().map(item -> item.getExecuteCycleStageId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:1880485_1_70441
                }
                if (listOmsExecuteCycleStage_6 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6) && listOmsExecuteCycleStage_6 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6)) {
                    implementMergeTargetContentCustomProcessExecutionCycleComReqDto.setSubCycleEndTimeExecuteCycleStageList(listOmsExecuteCycleStage_6.stream().map(item -> item.getExecuteCycleStageId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:1880486_1_70441
                }

                /*D3执行合并目标内容自定义过程执行周期(公共)[9836]   */

                implementMergeTargetContentCustomProcessExecutionCycleComRespDto = implementMergeTargetContentCustomProcessExecutionCycleCom(implementMergeTargetContentCustomProcessExecutionCycleComReqDto)/*vcase invoke 同服务,同domain*/;


            }
            if ((implementMergeTargetContentCustomProcessExecutionCycleComRespDto != null && implementMergeTargetContentCustomProcessExecutionCycleComRespDto.getExecuteCycleStageList() != null && implementMergeTargetContentCustomProcessExecutionCycleComRespDto.getExecuteCycleStageList().size() > 0)) {
                //if(D3执行合并目标内容自定义过程执行周期(公共).执行周期阶段列表数据集条数 大于 0)  70442

                List<OmsExecuteCycleStage> listOmsExecuteCycleStage_8 = new ArrayList<>();
                if (implementMergeTargetContentCustomProcessExecutionCycleComRespDto != null) {
                    BatchQueryTargetCycleListReq batchQueryTargetCycleListReq = new BatchQueryTargetCycleListReq();
                    batchQueryTargetCycleListReq.setIsArchive("FALSE");//sourceId:1880503_1_70444
                    if (implementMergeTargetContentCustomProcessExecutionCycleComRespDto != null) {
                        batchQueryTargetCycleListReq.setExecuteCycleStageList(implementMergeTargetContentCustomProcessExecutionCycleComRespDto.getExecuteCycleStageList());//list-field-assign//sourceId:1880501_1_70444
                    }
                    if (reqDto != null) {
                        batchQueryTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1880505_1_70444
                    }

                    /*3-3-07批量查执行周期列表（by执行周期ID）[2194]   */
                    Assert.isNull(batchQueryTargetCycleListReq.getEvaluationTemplateId(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07批量查执行周期列表（by执行周期ID）-评价模板ID不能为空", false);
                    Assert.isNull(batchQueryTargetCycleListReq.getIsArchive(), "D3分析目标内容自定义过程执行周期范围(公共)-3-3-07批量查执行周期列表（by执行周期ID）-是否存档不能为空", false);
                    listOmsExecuteCycleStage_8 = mOmsExecuteCycleStageService.batchQueryTargetCycleList(batchQueryTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


                }
//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
                if (listOmsExecuteCycleStage_8 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_8) && listOmsExecuteCycleStage_8.size() > 0 && omsExecuteCycleStage != null) {
                    ImplementElevenReceivingFieldReqDto receptionServiceReq_1 = new ImplementElevenReceivingFieldReqDto();
                    if (listOmsExecuteCycleStage_8 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_8) && listOmsExecuteCycleStage_8 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_8)) {
                        OmsExecuteCycleStage finalOmsExecuteCycleStage1 = omsExecuteCycleStage;
                        receptionServiceReq_1.setExecuteCycleStageList(//objList-to-objLists
                                listOmsExecuteCycleStage_8.stream().map(item -> {
                                    ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
                                    elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:376191_2_70445
                                    elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:376193_2_70445
                                    elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:376194_2_70445
                                    elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:376195_2_70445
                                    elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:376196_2_70445
                                    elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:376197_2_70445
                                    elm.setCycleTypeInstanceCode(item.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:376198_2_70445
                                    elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:376199_2_70445
                                    elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:376200_2_70445
                                    elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:376201_2_70445
                                    elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:376202_2_70445
                                    elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:376203_2_70445
                                    elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:376204_2_70445
                                    elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:376205_2_70445
                                    elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:376206_2_70445
                                    elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:376207_2_70445
                                    elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:376208_2_70445
                                    elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:376209_2_70445
                                    elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:376210_2_70445
                                    elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:376212_2_70445
                                    elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:376213_2_70445
                                    elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:376214_2_70445
                                    elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:376219_2_70445
                                    elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:376220_2_70445
                                    if (finalOmsExecuteCycleStage1 != null) {
                                        elm.setRelateExecuteCycleStageId(finalOmsExecuteCycleStage1.getExecuteCycleStageId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376192_2_70445
                                        elm.setRelateContentTypeCode(finalOmsExecuteCycleStage1.getRelateContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376215_2_70445
                                        elm.setRelateContentId(finalOmsExecuteCycleStage1.getRelateContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376216_2_70445
                                    }
                                    if (reqDto != null) {
                                        elm.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376211_2_70445
                                        elm.setTargetId(reqDto.getTargetId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376217_2_70445
                                        elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376218_2_70445
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1879897_1_70445
                    }

                    /*M3-接收出参数据集：执行周期阶段列表[9482]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_2 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_1);


                    receptionServiceRes_1 = receptionServiceRes_2;
                }
            }
        }
        AnalysisTargetContentCustomProcessExecutionCycleRangeComRespDto retData = new AnalysisTargetContentCustomProcessExecutionCycleRangeComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setExecuteCycleStageList(receptionServiceRes_1.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880506_1
        }
        if (listOmsExecuteCycleStage_5 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_5) && listOmsExecuteCycleStage_5 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_5)) {
            retData.setSubCycleStartTimeExecuteCycleStageList(listOmsExecuteCycleStage_5.stream().map(item -> item.getCycleId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:1886824_1
        }
        if (listOmsExecuteCycleStage_7 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_7) && listOmsExecuteCycleStage_7 != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage_7)) {
            retData.setSubCycleEndTimeExecuteCycleStageList(listOmsExecuteCycleStage_7.stream().map(item -> item.getCycleId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:1886825_1
        }


        return retData;
    }

    /**
     * D3执行合并目标内容自定义过程执行周期(公共)[9836]
     * gen by moon at 6/22/2024, 9:31:07 PM
     */
    @Trace(operationName = "D3执行合并目标内容自定义过程执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementMergeTargetContentCustomProcessExecutionCycleComRespDto implementMergeTargetContentCustomProcessExecutionCycleCom(ImplementMergeTargetContentCustomProcessExecutionCycleComReqDto reqDto) {


        ImplementElevenReceivingFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getWithinSubCycleExecuteCycleStageList() != null && reqDto.getWithinSubCycleExecuteCycleStageList().size() > 0 && reqDto != null && reqDto.getSubCycleStartTimeExecuteCycleStageList() != null && reqDto.getSubCycleStartTimeExecuteCycleStageList().size() > 0)) {
            //if((D3执行合并目标内容自定义过程执行周期(公共).子周期时间范围内执行周期列表数据集条数 大于 0 and D3执行合并目标内容自定义过程执行周期(公共).子周期开始时间所在执行周期列表数据集条数 大于 0))  70411

            ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto = null;
            ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto = new ImplementUnionMultipleDataSetsComReqDto();
            if (reqDto != null) {
                //simpleList-to-objLists
                for (String item : reqDto.getWithinSubCycleExecuteCycleStageList()) {
                    DataSetsListOneDto oneItem = new DataSetsListOneDto();
                    if (reqDto != null) {
                        oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378802_2_70602
                    }

                    implementUnionMultipleDataSetsComReqDto.getDataSetsListOne().add(oneItem);
                }//sourceId:1887125_1_70602
//simpleList-to-objLists
                for (String item : reqDto.getSubCycleStartTimeExecuteCycleStageList()) {
                    DataSetsListTwoDto oneItem = new DataSetsListTwoDto();
                    if (reqDto != null) {
                        oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378807_2_70602
                    }

                    implementUnionMultipleDataSetsComReqDto.getDataSetsListTwo().add(oneItem);
                }//sourceId:1887126_1_70602
            }

            /*D2执行多数据集取并集(公共)[5320]   */

            implementUnionMultipleDataSetsComRespDto = interfaceModeService.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((reqDto != null && reqDto.getSubCycleEndTimeExecuteCycleStageList() != null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size() > 0)) {
                //if(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 大于 0)  70430

                ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto_2 = null;
                if (implementUnionMultipleDataSetsComRespDto != null) {
                    ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto_1 = new ImplementUnionMultipleDataSetsComReqDto();
                    if (implementUnionMultipleDataSetsComRespDto != null && implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList() != null && !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList())) {
                        implementUnionMultipleDataSetsComReqDto_1.setDataSetsListOne(implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887125_1_70603
                    }
                    if (reqDto != null) {
                        //simpleList-to-objLists
                        for (String item : reqDto.getSubCycleEndTimeExecuteCycleStageList()) {
                            DataSetsListTwoDto oneItem = new DataSetsListTwoDto();
                            if (reqDto != null) {
                                oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378807_2_70603
                            }

                            implementUnionMultipleDataSetsComReqDto_1.getDataSetsListTwo().add(oneItem);
                        }//sourceId:1887126_1_70603
                    }

                    /*D2执行多数据集取并集(公共)[5320]   */

                    implementUnionMultipleDataSetsComRespDto_2 = interfaceModeService.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
                if (implementUnionMultipleDataSetsComRespDto_2 != null) {
                    ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
                    if (implementUnionMultipleDataSetsComRespDto_2 != null && implementUnionMultipleDataSetsComRespDto_2.getUnionMultipleDataSetsList() != null && !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto_2.getUnionMultipleDataSetsList())) {
                        receptionServiceReq.setExecuteCycleStageList(//objList-to-objLists
                                implementUnionMultipleDataSetsComRespDto_2.getUnionMultipleDataSetsList().stream().map(item -> {
                                    ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
                                    if (item != null) {
                                        elm.setExecuteCycleStageId(item.getCustomField());//SimpleFieldAssign//sourceId:376545_2_70432
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880481_1_70432
                    }

                    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

                    receptionServiceRes = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq);


                    receptionServiceRes_1 = receptionServiceRes;
                }
            } else if ((reqDto != null && reqDto.getSubCycleEndTimeExecuteCycleStageList() != null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size() == 0)) {
                //elseif(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 等于 0)  70433

//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
                if (implementUnionMultipleDataSetsComRespDto != null) {
                    ImplementElevenReceivingFieldReqDto receptionServiceReq_1 = new ImplementElevenReceivingFieldReqDto();
                    if (implementUnionMultipleDataSetsComRespDto != null && implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList() != null && !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList())) {
                        receptionServiceReq_1.setExecuteCycleStageList(//objList-to-objLists
                                implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList().stream().map(item -> {
                                    ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
                                    if (item != null) {
                                        elm.setExecuteCycleStageId(item.getCustomField());//SimpleFieldAssign//sourceId:376545_2_70434
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880481_1_70434
                    }

                    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_2 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_1);


                    receptionServiceRes_1 = receptionServiceRes_2;
                }
            }
        } else if ((reqDto != null && reqDto.getWithinSubCycleExecuteCycleStageList() != null && reqDto.getWithinSubCycleExecuteCycleStageList().size() > 0 && reqDto != null && reqDto.getSubCycleStartTimeExecuteCycleStageList() != null && reqDto.getSubCycleStartTimeExecuteCycleStageList().size() == 0)) {
            //elseif((D3执行合并目标内容自定义过程执行周期(公共).子周期时间范围内执行周期列表数据集条数 大于 0 and D3执行合并目标内容自定义过程执行周期(公共).子周期开始时间所在执行周期列表数据集条数 等于 0))  70416

            if ((reqDto != null && reqDto.getSubCycleEndTimeExecuteCycleStageList() != null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size() > 0)) {
                //if(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 大于 0)  70419

                ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto_3 = null;
                ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto_2 = new ImplementUnionMultipleDataSetsComReqDto();
                if (reqDto != null) {
                    //simpleList-to-objLists
                    for (String item : reqDto.getWithinSubCycleExecuteCycleStageList()) {
                        DataSetsListOneDto oneItem = new DataSetsListOneDto();
                        if (reqDto != null) {
                            oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378802_2_70604
                        }

                        implementUnionMultipleDataSetsComReqDto_2.getDataSetsListOne().add(oneItem);
                    }//sourceId:1887125_1_70604
//simpleList-to-objLists
                    for (String item : reqDto.getSubCycleEndTimeExecuteCycleStageList()) {
                        DataSetsListTwoDto oneItem = new DataSetsListTwoDto();
                        if (reqDto != null) {
                            oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378807_2_70604
                        }

                        implementUnionMultipleDataSetsComReqDto_2.getDataSetsListTwo().add(oneItem);
                    }//sourceId:1887126_1_70604
                }

                /*D2执行多数据集取并集(公共)[5320]   */

                implementUnionMultipleDataSetsComRespDto_3 = interfaceModeService.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
                if (implementUnionMultipleDataSetsComRespDto_3 != null) {
                    ImplementElevenReceivingFieldReqDto receptionServiceReq_2 = new ImplementElevenReceivingFieldReqDto();
                    if (implementUnionMultipleDataSetsComRespDto_3 != null && implementUnionMultipleDataSetsComRespDto_3.getUnionMultipleDataSetsList() != null && !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto_3.getUnionMultipleDataSetsList())) {
                        receptionServiceReq_2.setExecuteCycleStageList(//objList-to-objLists
                                implementUnionMultipleDataSetsComRespDto_3.getUnionMultipleDataSetsList().stream().map(item -> {
                                    ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
                                    if (item != null) {
                                        elm.setExecuteCycleStageId(item.getCustomField());//SimpleFieldAssign//sourceId:376545_2_70422
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880481_1_70422
                    }

                    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_3 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_2);


                    receptionServiceRes_1 = receptionServiceRes_3;
                }
            } else if ((reqDto != null && reqDto.getSubCycleEndTimeExecuteCycleStageList() != null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size() == 0)) {
                //elseif(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 等于 0)  70420

//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
                ImplementElevenReceivingFieldReqDto receptionServiceReq_3 = new ImplementElevenReceivingFieldReqDto();
                if (reqDto != null) {
                    //simpleList-to-objLists
                    for (String item : reqDto.getWithinSubCycleExecuteCycleStageList()) {
                        ExecuteCycleStageDto oneItem = new ExecuteCycleStageDto();
                        if (reqDto != null) {
                            oneItem.setExecuteCycleStageId(item);//SimpleFieldAssign//sourceId:376545_2_70423
                        }

                        receptionServiceReq_3.getExecuteCycleStageList().add(oneItem);
                    }//sourceId:1880481_1_70423
                }

                /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

                receptionServiceRes_4 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_3);


                receptionServiceRes_1 = receptionServiceRes_4;
            }
        } else if ((reqDto != null && reqDto.getWithinSubCycleExecuteCycleStageList() != null && reqDto.getWithinSubCycleExecuteCycleStageList().size() == 0 && reqDto != null && reqDto.getSubCycleStartTimeExecuteCycleStageList() != null && reqDto.getSubCycleStartTimeExecuteCycleStageList().size() > 0)) {
            //elseif((D3执行合并目标内容自定义过程执行周期(公共).子周期时间范围内执行周期列表数据集条数 等于 0 and D3执行合并目标内容自定义过程执行周期(公共).子周期开始时间所在执行周期列表数据集条数 大于 0))  70417

            if ((reqDto != null && reqDto.getSubCycleEndTimeExecuteCycleStageList() != null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size() > 0)) {
                //if(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 大于 0)  70425

                ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto_4 = null;
                ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto_3 = new ImplementUnionMultipleDataSetsComReqDto();
                if (reqDto != null) {
                    //simpleList-to-objLists
                    for (String item : reqDto.getSubCycleStartTimeExecuteCycleStageList()) {
                        DataSetsListOneDto oneItem = new DataSetsListOneDto();
                        if (reqDto != null) {
                            oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378802_2_70605
                        }

                        implementUnionMultipleDataSetsComReqDto_3.getDataSetsListOne().add(oneItem);
                    }//sourceId:1887125_1_70605
//simpleList-to-objLists
                    for (String item : reqDto.getSubCycleEndTimeExecuteCycleStageList()) {
                        DataSetsListTwoDto oneItem = new DataSetsListTwoDto();
                        if (reqDto != null) {
                            oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378807_2_70605
                        }

                        implementUnionMultipleDataSetsComReqDto_3.getDataSetsListTwo().add(oneItem);
                    }//sourceId:1887126_1_70605
                }

                /*D2执行多数据集取并集(公共)[5320]   */

                implementUnionMultipleDataSetsComRespDto_4 = interfaceModeService.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_5 = null;
                if (implementUnionMultipleDataSetsComRespDto_4 != null) {
                    ImplementElevenReceivingFieldReqDto receptionServiceReq_4 = new ImplementElevenReceivingFieldReqDto();
                    if (implementUnionMultipleDataSetsComRespDto_4 != null && implementUnionMultipleDataSetsComRespDto_4.getUnionMultipleDataSetsList() != null && !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto_4.getUnionMultipleDataSetsList())) {
                        receptionServiceReq_4.setExecuteCycleStageList(//objList-to-objLists
                                implementUnionMultipleDataSetsComRespDto_4.getUnionMultipleDataSetsList().stream().map(item -> {
                                    ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
                                    if (item != null) {
                                        elm.setExecuteCycleStageId(item.getCustomField());//SimpleFieldAssign//sourceId:376545_2_70429
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880481_1_70429
                    }

                    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_5 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_4);


                    receptionServiceRes_1 = receptionServiceRes_5;
                }
            } else if ((reqDto != null && reqDto.getSubCycleEndTimeExecuteCycleStageList() != null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size() == 0)) {
                //elseif(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 等于 0)  70426

//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_6 = null;
                ImplementElevenReceivingFieldReqDto receptionServiceReq_5 = new ImplementElevenReceivingFieldReqDto();
                if (reqDto != null) {
                    //simpleList-to-objLists
                    for (String item : reqDto.getSubCycleStartTimeExecuteCycleStageList()) {
                        ExecuteCycleStageDto oneItem = new ExecuteCycleStageDto();
                        if (reqDto != null) {
                            oneItem.setExecuteCycleStageId(item);//SimpleFieldAssign//sourceId:376545_2_70427
                        }

                        receptionServiceReq_5.getExecuteCycleStageList().add(oneItem);
                    }//sourceId:1880481_1_70427
                }

                /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

                receptionServiceRes_6 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_5);


                receptionServiceRes_1 = receptionServiceRes_6;
            }
        } else if ((reqDto != null && reqDto.getWithinSubCycleExecuteCycleStageList() != null && reqDto.getWithinSubCycleExecuteCycleStageList().size() == 0 && reqDto != null && reqDto.getSubCycleStartTimeExecuteCycleStageList() != null && reqDto.getSubCycleStartTimeExecuteCycleStageList().size() == 0)) {
            //elseif((D3执行合并目标内容自定义过程执行周期(公共).子周期时间范围内执行周期列表数据集条数 等于 0 and D3执行合并目标内容自定义过程执行周期(公共).子周期开始时间所在执行周期列表数据集条数 等于 0))  70436

            if ((reqDto != null && reqDto.getSubCycleEndTimeExecuteCycleStageList() != null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size() > 0)) {
                //if(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 大于 0)  70438

//ModelCode: receptionService
                ImplementElevenReceivingFieldRespDto receptionServiceRes_7 = null;
                ImplementElevenReceivingFieldReqDto receptionServiceReq_6 = new ImplementElevenReceivingFieldReqDto();
                if (reqDto != null) {
                    //simpleList-to-objLists
                    for (String item : reqDto.getSubCycleEndTimeExecuteCycleStageList()) {
                        ExecuteCycleStageDto oneItem = new ExecuteCycleStageDto();
                        if (reqDto != null) {
                            oneItem.setExecuteCycleStageId(item);//SimpleFieldAssign//sourceId:376545_2_70440
                        }

                        receptionServiceReq_6.getExecuteCycleStageList().add(oneItem);
                    }//sourceId:1880481_1_70440
                }

                /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

                receptionServiceRes_7 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_6);


                receptionServiceRes_1 = receptionServiceRes_7;
            } else {
                //else  70447

//异常结束 70448
                throw new BizException("220100389", "对不起，找不到周期ID~", false);
            }
        }
        ImplementMergeTargetContentCustomProcessExecutionCycleComRespDto retData = new ImplementMergeTargetContentCustomProcessExecutionCycleComRespDto();
        if (receptionServiceRes_1 != null && receptionServiceRes_1.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(receptionServiceRes_1.getExecuteCycleStageList())) {
            retData.setExecuteCycleStageList(receptionServiceRes_1.getExecuteCycleStageList().stream().map(item -> item.getExecuteCycleStageId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:1880483_1
        }


        return retData;
    }

    /**
     * D3执行修正子周期开始或结束的自定义过程执行周期(公共)[9847]
     * gen by moon at 7/6/2024, 11:57:32 PM
     */
    @Trace(operationName = "D3执行修正子周期开始或结束的自定义过程执行周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementModifyStartOrEndDefinedExecCycleComRespDto implementModifyStartOrEndDefinedExecCycleCom(ImplementModifyStartOrEndDefinedExecCycleComReqDto reqDto) {


        if ((reqDto != null && reqDto.getExecuteCycleStageList() != null && reqDto.getExecuteCycleStageList().size() > 0)) {
            //if(D3执行修正子周期开始或结束的自定义过程执行周期(公共).执行周期阶段列表数据集条数 大于 0)  70594

            List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
            BatchQueryExecuteCycleStageReq batchQueryExecuteCycleStageReq = new BatchQueryExecuteCycleStageReq();
            if (reqDto != null) {
                batchQueryExecuteCycleStageReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList());//list-field-assign//sourceId:1887092_1_70595
                batchQueryExecuteCycleStageReq.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1887100_1_70595
                batchQueryExecuteCycleStageReq.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1887110_1_70595
                batchQueryExecuteCycleStageReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887111_1_70595
                batchQueryExecuteCycleStageReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887095_1_70595
            }

            /*3-3-07批量查询执行周期阶段by周期ID[3149]   */

            listOmsExecuteCycleStage = mOmsExecuteCycleStageService.batchQueryExecuteCycleStage(batchQueryExecuteCycleStageReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((listOmsExecuteCycleStage != null && listOmsExecuteCycleStage != null && listOmsExecuteCycleStage.size() > 0 && reqDto != null && reqDto.getCycleStartTime() != null)) {
                //if((3-3-07批量查询执行周期阶段by周期ID.执行周期阶段列表数据集条数 大于 0 and D3执行修正子周期开始或结束的自定义过程执行周期(公共).周期开始时间 值不等于空 ))  70596

                boolean bOOLEAN;
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
                    List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 = new ArrayList<>();
                    if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                        listOmsExecuteCycleStage_2 = //objList-to-objLists
                                listOmsExecuteCycleStage.stream().map(item -> {
                                    OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
                                    elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:378783_2_70598
                                    elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:378787_2_70598
                                    elm.setFillEndtTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:390023_2_70598
                                    elm.setEvaluateEndtTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:390025_2_70598
                                    if (reqDto != null) {
                                        elm.setCycleStartTime(reqDto.getCycleStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:378786_2_70598
                                        elm.setFillStartTime(reqDto.getCycleStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:390022_2_70598
                                        elm.setEvaluateStartTime(reqDto.getCycleStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:390024_2_70598
                                    }
                                    return elm;
                                }).collect(Collectors.toList());//objList-to-objLists//sourceId:1887113_1_70598
                    }

                    /*3-3-07批量改执行周期阶段[3150]   */

                    bOOLEAN = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;


                }
            } else if ((listOmsExecuteCycleStage != null && listOmsExecuteCycleStage != null && listOmsExecuteCycleStage.size() > 0 && reqDto != null && reqDto.getCycleEndTime() != null)) {
                //elseif((3-3-07批量查询执行周期阶段by周期ID.执行周期阶段列表数据集条数 大于 0 and D3执行修正子周期开始或结束的自定义过程执行周期(公共).周期结束时间 值不等于空 ))  70597

                boolean bOOLEAN_1;
                if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage.size() > 0) {
                    List<OmsExecuteCycleStage> listOmsExecuteCycleStage_3 = new ArrayList<>();
                    if (listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage) && listOmsExecuteCycleStage != null && !CollectionUtil.isEmpty(listOmsExecuteCycleStage)) {
                        listOmsExecuteCycleStage_3 = //objList-to-objLists
                                listOmsExecuteCycleStage.stream().map(item -> {
                                    OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
                                    elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:378783_2_70599
                                    elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:378786_2_70599
                                    elm.setFillStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:390022_2_70599
                                    elm.setEvaluateStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:390024_2_70599
                                    if (reqDto != null) {
                                        elm.setCycleEndTime(reqDto.getCycleEndTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:378787_2_70599
                                        elm.setFillEndtTime(reqDto.getCycleEndTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:390023_2_70599
                                        elm.setEvaluateEndtTime(reqDto.getCycleEndTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:390025_2_70599
                                    }
                                    return elm;
                                }).collect(Collectors.toList());//objList-to-objLists//sourceId:1887113_1_70599
                    }

                    /*3-3-07批量改执行周期阶段[3150]   */

                    bOOLEAN_1 = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_3)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
        }
        ImplementModifyStartOrEndDefinedExecCycleComRespDto retData = new ImplementModifyStartOrEndDefinedExecCycleComRespDto();


        return retData;
    }

    /**
     * D3查询被评对象目标周期详情（开始小于等于结束时间大于等于）(公共)[10221]
     * gen by moon at 9/18/2024, 7:31:54 PM
     */
    @Trace(operationName = "D3查询被评对象目标周期详情（开始小于等于结束时间大于等于）(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaObjTargetCycleEqualStartAndGreaterDetailComRespDto queryEvaObjTargetCycleEqualStartAndGreaterDetailCom(QueryEvaObjTargetCycleEqualStartAndGreaterDetailComReqDto reqDto) {


        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 = null;
//步骤0: 3-3-09查询被评对象目标周期详情（开始小于等于结束时间大于等于） - queryEvaObjTargetCycleEqualStartAndGreaterDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleEqualStartAndGreaterDetailReq queryEvaObjTargetCycleEqualStartAndGreaterDetailReq = new QueryEvaObjTargetCycleEqualStartAndGreaterDetailReq();
        if (reqDto != null) {
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2002359_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2001312_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2001313_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:2001314_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:2001326_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2004610_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:2001325_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:2004603_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:2001315_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2001316_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:2001317_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:2005670_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2001318_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2001319_1
            queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2001371_1
        }

        /*3-3-09查询被评对象目标周期详情（开始小于等于结束时间大于等于）[9460]   */

        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleEqualStartAndGreaterDetail(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;

        QueryEvaObjTargetCycleEqualStartAndGreaterDetailComRespDto retData = new QueryEvaObjTargetCycleEqualStartAndGreaterDetailComRespDto();
        if (omsEvaluationObjectTargetCycle_1 != null) {
            retData.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2001340_1
            retData.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2001341_1
            retData.setCycleId(omsEvaluationObjectTargetCycle_1.getCycleId());//SimpleFieldAssign//sourceId:2001342_1
            retData.setCyclelAlias(omsEvaluationObjectTargetCycle_1.getCyclelAlias());//SimpleFieldAssign//sourceId:2001343_1
            retData.setCycleStartTime(omsEvaluationObjectTargetCycle_1.getCycleStartTime());//SimpleFieldAssign//sourceId:2001344_1
            retData.setCycleEndTime(omsEvaluationObjectTargetCycle_1.getCycleEndTime());//SimpleFieldAssign//sourceId:2001345_1
            retData.setCycleTypeCode(omsEvaluationObjectTargetCycle_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:2001346_1
            retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:2001347_1
        }


        return retData;
    }
    //
}
